二叉树的深度（前序、中序、后续）遍历-java实现

初始化

参见本博客里的 二叉树层次遍历 ，树结构如下。

/**
     * init tree  1 2 3 4 null 5 6
     *         1
     *     2      3
     *  4  null 5   6
     * 
     */

递归实现

 /**
     * 前序递归实现
     * @param root
     */
    public static void preOrderTraversal(TreeNode root){
        if(root == null){
            return;
        }
        System.out.print(root.getValue());
        preOrderTraversal(root.getLeft());
        preOrderTraversal(root.getRight());
    }

    /**
     * 中序递归实现
     * @param root
     */
    public static void ordinalTraversal(TreeNode root){
        if(root == null){
            return;
        }
        ordinalTraversal(root.getLeft());
        System.out.print(root.getValue());
        ordinalTraversal(root.getRight());
    }

    /**
     * 后序递归实现
     * @param root
     */
    public static void postorderTraversal(TreeNode root){
        if(root == null){
            return;
        }
        postorderTraversal(root.getLeft());
        postorderTraversal(root.getRight());
        System.out.print(root.getValue());
    }

非递归实现

 /**
     * 非递归前序遍历
     * @param root
     */
    public static void preOrderTraversalNonRecursion(TreeNode root){
        if(root == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        while (node != null || !stack.isEmpty()){
            if(node != null){
                System.out.print(node.getValue());
                stack.push(node);
                node = node.getLeft();
            }else{
                TreeNode node1 = stack.pop();
                node = node1.getRight();
            }
        }
    }

    /**
     * 非递归中序遍历
     * @param root
     */
    public static void ordinalTraversalNonRecursion(TreeNode root){
        if(root == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        while(node != null || !stack.isEmpty()){
            if(node != null){
                stack.push(node);
                node = node.getLeft();
            }else {
                TreeNode node1 = stack.pop();
                System.out.print(node1.getValue());
                node = node1.getRight();
            }
        }
    }

    /**
     * 非递归后序遍历
     * @param root
     */
    public static void postOrderTraversalNonRecursion(TreeNode root){
        if(root == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        TreeNode lastNode = null;
        while(node != null || !stack.isEmpty()){
            if(node != null){
                stack.push(node);
                node = node.getLeft();
            }else {
                TreeNode node1 = stack.peek();
                if(node1.getRight() != null && node1.getRight() != lastNode){
                    node = node1.getRight();
                }else{
                    System.out.print(node1.getValue());
                    lastNode = stack.pop();
                }
            }
        }
    }

main 方法

public static void main(String[] args) {
        TreeNode root = TreeNode.initTree();
        //递归实现
        preOrderTraversal(root);
        System.out.println();
        ordinalTraversal(root);
        System.out.println();
        postorderTraversal(root);
        System.out.println();
        System.out.println("---非递归实现 -----");
        //非递归实现
        preOrderTraversalNonRecursion(root);
        System.out.println();
        ordinalTraversalNonRecursion(root);
        System.out.println();
        postOrderTraversalNonRecursion(root);
        System.out.println();
    }

运行结果

参考资料

二叉树遍历(先序、中序、后序) （配的图文思路很好）
二叉树遍历算法（深度优先、广度优先遍历，前序、中序、后序、层次）及Java实现