二叉树（构建、先序、中序、后序、层序（递归，非递归）遍历，求树的深度）

二叉树构造类

    /**
     * 二叉树类
     * @日期： 2018年6月12日 下午10:37:49
     * @作者： Chendb
     */
    class TreeNode {

        // 节点值
        private int val = 0;
        
        // 左子树
        private TreeNode left = null;
        
        // 右子树
        private TreeNode right = null;
        
        public TreeNode (int val) {
            this.val = val;
            this.left = null;
            this.right = null;
        }

        public TreeNode() {
            
        }
        
        public int getVal() {
            return val;
        }

        public void setVal(int val) {
            this.val = val;
        }

        public TreeNode getLeft() {
            return left;
        }

        public void setLeft(TreeNode left) {
            this.left = left;
        }

        public TreeNode getRight() {
            return right;
        }

        public void setRight(TreeNode right) {
            this.right = right;
        }
    }

构造二叉树

     /**
     * 创建一颗二叉树
     * @param array 构建二叉树的数据数组
     * @return 二叉树
     */
    public TreeNode createBinaryTree(int[] array) {
        
        if (array == null || array.length == 0) {
            return new TreeNode();
        }
        
        LinkedList<TreeNode> nodeList = new LinkedList<>();
        for (int i = 0; i < array.length; i++) {
            nodeList.add(new TreeNode(array[i]));
        }
        
        for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
            //左子树
            nodeList.get(parentIndex).left = nodeList.get(parentIndex * 2 + 1);
            //右子树
            nodeList.get(parentIndex).right = nodeList.get(parentIndex * 2 + 2);
        }
        
        // 最后一个父节点可能没有右子树
        int lastParentIndex = array.length / 2 - 1;
        nodeList.get(lastParentIndex).left = nodeList.get(lastParentIndex * 2 + 1);
        
        // 当为奇数时，最后一个父节点有右子树
        if (array.length % 2 == 1) {
            nodeList.get(lastParentIndex).right = nodeList.get(lastParentIndex * 2 + 2);
        }
        
        return nodeList.get(0);
    }

先序遍历（递归）

    /**
     * 先序遍历（递归）
     * @param root 根节点
     */
    public void preOrderTraverseByRecursion(TreeNode root) {
        if (root == null) {
            return ;
        }
        
        // 先访问根节点
        System.out.println(root.getVal());
        // 次访问左子树
        preOrderTraverseByRecursion(root.getLeft());
        // 后访问右子树
        preOrderTraverseByRecursion(root.getRight());
    }           

先序遍历

    /**
     * 先序遍历
     * @param root 根节点
     */
    public void preOrderTraverse(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        
        // 利用栈的先进后出特性进行遍历
        while (!stack.isEmpty()) {
            
            TreeNode treeNode = stack.pop();
            // 先访问根节点
            System.out.println(treeNode.getVal());
            
            if ( treeNode.getRight() != null) {
                // 放入右节点
                stack.push(treeNode.getRight());
            }
            
            if ( treeNode.getLeft() != null) {
                // 放入左节点
                stack.push(treeNode.getLeft());
            }
        }
    }

中序遍历（递归）

    /**
     * 中序遍历（递归）
     * @param root 根节点
     */
    public void inOrderTraverseByRecursion(TreeNode root) {
        if (root == null) {
            return ;
        }
        
        // 先次访问左子树
        inOrderTraverseByRecursion(root.getLeft());
        // 次访问根节点
        System.out.println(root.getVal());
        // 后访问右子树
        inOrderTraverseByRecursion(root.getRight());
    }

中序遍历

    /**
     * 中序遍历
     * @param root 根节点
     */
    public void inOrderTraverse(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        TreeNode treeNode = root ;
        
        // 利用栈的先进后出特性进行遍历
        while (treeNode != null || !stack.isEmpty()) {
            
            // 存在左子树
            while (treeNode != null) {
                stack.push(treeNode);
                treeNode = treeNode.getLeft();
            }
            
            // 栈非空
            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                System.out.println(treeNode.getVal());
                treeNode = treeNode.getRight();
            }
        }
    }

后序遍历（递归）

    /**
     * 后序遍历（递归）
     * @param root 根节点
     */
    public void afterOrderTraverseByRecursion(TreeNode root) {
        if (root == null) {
            return ;
        }
        
        // 后访问左子树
        afterOrderTraverseByRecursion(root.getLeft());
        // 次访问右子树
        afterOrderTraverseByRecursion(root.getRight());
        // 先访问根节点
        System.out.println(root.getVal());
    }

后序遍历

    /**
     * 后序遍历
     * @param root 根节点
     */
    public void afterOrderTraverse(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        // 用来记录被访问的节点
        TreeNode visitNode = root ;
        TreeNode treeNode = root ;
        
        // 利用栈的先进后出特性进行遍历
        while (treeNode != null) {
            
            // 左子树入栈
            for (;treeNode.getLeft() != null ;treeNode = treeNode.getLeft()) {
                stack.push(treeNode);
            }
            
            // 当前节点没有右子树或者右子树已经被访问
            while (treeNode != null && (treeNode.getRight() == null || treeNode.getRight() == visitNode)) {
                System.out.println(treeNode.getVal());
                // 记录上一个被访问的节点
                visitNode = treeNode;
                if (stack.isEmpty()) {
                    return;
                }
                treeNode = stack.pop();
            }
            
            // 处理右子树
            stack.push(treeNode);
            treeNode = treeNode.getRight();
        }
    }

层序遍历（递归）

    /**
     * 层序遍历（递归）
     * @param root 根节点
     */
    public void levelOrderTraverseByRecursion(TreeNode root) {
        if (root == null) {
            return;
        }

        int depth = getBinaryTreeDepthByRecursion(root);

        for (int i = 1; i <= depth; i++) {
            levelOrderTraverse(root, i);
        }
    }
    
    private void levelOrderTraverse(TreeNode treeNode,int level){
        if (treeNode == null || level < 1) {
            return;
        }

        if (level == 1) {
            System.out.println(treeNode.getVal());
            return;
        }

        // 访问左子树
        levelOrderTraverse(treeNode.getLeft(), level - 1);

        // 右子树
        levelOrderTraverse(treeNode.getRight(), level - 1);
    }

层序遍历

    /**
     * 层序遍历
     * @param root 根节点
     */
    public void levelOrderTraverse(TreeNode root) {
        if (root == null) {
            return ;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            System.out.println(treeNode.getVal());
            if (treeNode.getLeft() != null) {
                queue.offer(treeNode.getLeft());
            }
            if (treeNode.getRight() != null) {
                queue.offer(treeNode.getRight());
            }
        }
    }

树的深度（递归）

    /**
     * 获取二叉树的深度（递归）
     * @param root 根节点
     * @return 二叉树的深度
     */
    public int getBinaryTreeDepthByRecursion(TreeNode root) {
        
        if (root == null) {
            return 0;
        }
        
        int l = getBinaryTreeDepthByRecursion(root.left);
        int r = getBinaryTreeDepthByRecursion(root.right);
        
        if (l > r) {
            return l + 1;
        }
        
        return r + 1;
    }

树的深度

    /**
     * 获取二叉树的深度
     * @param root 根节点
     * @return 二叉树深度
     */
    public int getBinaryTreeDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        int depth = 0 ;
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int len = queue.size();
            depth++;
            while (len > 0) {
                TreeNode treeNode = queue.element();
                queue.poll();
                if (treeNode.getLeft() != null) {
                    queue.offer(treeNode.getLeft());
                }
                if(treeNode.getRight() != null) {
                    queue.offer(treeNode.getRight());
                }
                len--;
            }
        }
        return depth;
    }

 测试

public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 
        BinaryTree binaryTree = new BinaryTree();
        TreeNode root = binaryTree.createBinaryTree(array);
        System.out.println("前序遍历（递归）:");
        binaryTree.preOrderTraverseByRecursion(root);
        System.out.println("前序遍历:");
        binaryTree.preOrderTraverse(root);
        
        System.out.println("中序遍历（递归）:");
        binaryTree.inOrderTraverseByRecursion(root);
        System.out.println("中序遍历:");
        binaryTree.inOrderTraverse(root);
        
        System.out.println("后序遍历（递归）:");
        binaryTree.afterOrderTraverseByRecursion(root);
        System.out.println("后序遍历:");
        binaryTree.afterOrderTraverse(root);
        
        System.out.println("层序遍历（递归）:");
        binaryTree.levelOrderTraverseByRecursion(root);
        System.out.println("层序遍历:");
        binaryTree.levelOrderTraverse(root);
        
        int depth = binaryTree.getBinaryTreeDepthByRecursion(root);
        System.out.println("树的深度（递归）:" + depth);
        depth = binaryTree.getBinaryTreeDepth(root);
        System.out.println("树的深度:" + depth);
    }