二叉树的前序、中序、后序遍历（迭代法）

二叉树的前序、中序、后序遍历（迭代法）

好了，我们现在学会了使用递归来实现树的遍历，代码非常简单，也比较好理解，今天让我们来点挑战，其实也不难，来学习一下如何不使用递归来完成树的遍历呢。

前置知识比如 前序，中序，后序遍历的顺序我在递归法那里写了，就不重新赘述了，有需要的可以自己看下qaq。

前序遍历

前序遍历结果为：0 1 4 5 2 6 7

还是这颗树，我们来想一下，没有用递归的话，我们遍历到4的时候，怎么去遍历5呢？

原本我们用递归可以直接返回上一层，通过1 来找到5，可是现在不行了。我们需要找一个帮手来帮我们记住1才行。
回忆回忆，是不是栈和队列都可以帮我们保存之前的元素呢？
那我们到底是用栈还是队列？
答案是栈。我们知道，栈是先进后出，队列是先进先出。举个例子，我们将0先入队。

然后0遍历完，将其左右孩子入队

然后1 出队，将其左右孩子入队

这个时候是不是就发现问题了，我们的顺序是0,1，4，可是下一个出队的却是2 ,现在你应该明白选栈还是队列了吧。

前序遍历代码

代码都给了注释了
要注意我们入栈的顺序，先是右子树，再是左子树。
因为栈是先进后出，而我们是想先遍历左边的节点。
中左右！

  //这里要先将右子树添加进栈，
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }

 public static void main(String[] args) {
        TreeNode root = new TreeNode(0);
        root.left=new TreeNode(1);
        root.left.left=new TreeNode(4);
        root.left.right=new TreeNode(5);
        root.right=new TreeNode(2);
        root.right.left=new TreeNode(6);
        root.right.right=new TreeNode(7);

        preorderTraversal2(root);

    }

    private static void preorderTraversal2(TreeNode root) {
        //存放结果集合
        ArrayList<TreeNode> result = new ArrayList<TreeNode>();

        //定义栈帮助我们完成遍历
        //我这里使用 LinkedList 来模拟栈，
        // 用 Stack也能实现栈，不过这个类太老了，不推荐使用
        LinkedList<TreeNode> stack =new LinkedList<>();
        //先讲根节点入栈
        stack.add(root);

        //如果栈不为空，说明还有节点未遍历
        while(!stack.isEmpty()) {
            TreeNode node = stack.poll();
            result.add(node);
            
            //这里要先将右子树添加进栈，
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }


        for(TreeNode child : result){
            System.out.println(child.val);
        }
    }

中序遍历

接下来我们看下迭代法的中序遍历吧，大家可能认为应该像递归法一样，中序遍历和前序遍历只要交换下遍历节点的顺序就行了吧。
不过这里情况发生了变化，我们需要新引入一个指针来帮助我们遍历。

同样都是遍历，为什么前序遍历不需要呢？
前序遍历的顺序是 根左右；中序遍历的顺序是 左根右。
关键点就在这。

中序遍历结果为：4 1 5 0 6 2 7 

我自己尝试了下如果不用指针，怎么处理右边节点是个问题。想了半天还是用了指针方便点，你们如果知道可以给我说。

中序遍历代码

    public static void main(String[] args) {
        TreeNode root = new TreeNode(0);
        root.left=new TreeNode(1);
        root.left.left=new TreeNode(4);
        root.left.right=new TreeNode(5);
        root.right=new TreeNode(2);
        root.right.left=new TreeNode(6);
        root.right.right=new TreeNode(7);

//        preorderTraversal2(root);
        inorderTraversal(root);

    }
    
        private static void inorderTraversal(TreeNode root) {
        //存放结果集合
        ArrayList<TreeNode> result = new ArrayList<TreeNode>();
        //我这里使用 LinkedList 来模拟栈，
        // 用 Stack也能实现栈，不过这个类太老了，不推荐使用
        LinkedList<TreeNode> stack =new LinkedList<>();

        TreeNode tmp =root;
        while (tmp != null||!stack.isEmpty()){
            if (tmp!=null){
                stack.push(tmp);
                tmp=tmp.left;
            }else{
                // 说明我们已经遍历到最左了
                TreeNode node = stack.poll();
                result.add(node);
                tmp =node.right;
            }
        }

        for(TreeNode child : result){
            System.out.println(child.val);
        }
    }

后序遍历

后序遍历其实和前序遍历差不多，会了前序遍历肯定会后序遍历。
还是来观察我们的遍历顺序，这点很重要。
前序遍历：根左右；
后序遍历：左右根

我们把前序遍历改成 根右左的遍历顺序，然后翻转输出是不是就是左右根的顺序了。

后序遍历结果为：4 5 1 6 7 2 0

后序遍历代码

   public static void main(String[] args) {
        TreeNode root = new TreeNode(0);
        root.left=new TreeNode(1);
        root.left.left=new TreeNode(4);
        root.left.right=new TreeNode(5);
        root.right=new TreeNode(2);
        root.right.left=new TreeNode(6);
        root.right.right=new TreeNode(7);

//        preorderTraversal2(root);
//        inorderTraversal(root);
        postorderTraversal(root);

    }

    //中序遍历
        private static void inorderTraversal(TreeNode root) {
        //存放结果集合
        ArrayList<TreeNode> result = new ArrayList<TreeNode>();
        //我这里使用 LinkedList 来模拟栈，
        // 用 Stack也能实现栈，不过这个类太老了，不推荐使用
        LinkedList<TreeNode> stack =new LinkedList<>();

        TreeNode tmp =root;
        while (tmp != null||!stack.isEmpty()){
            if (tmp!=null){
                stack.push(tmp);
                tmp=tmp.left;
            }else{
                // 说明我们已经遍历到最左了
                TreeNode node = stack.poll();
                result.add(node);
                tmp =node.right;
            }
        }

        for(TreeNode child : result){
            System.out.println(child.val);
        }
    }

    // 后序遍历
    private static void postorderTraversal(TreeNode root){
        //存放结果集合
        ArrayList<TreeNode> result = new ArrayList<TreeNode>();

        //定义栈帮助我们完成遍历
        //我这里使用 LinkedList 来模拟栈，
        // 用 Stack也能实现栈，不过这个类太老了，不推荐使用
        LinkedList<TreeNode> stack =new LinkedList<>();
        //先讲根节点入栈
        stack.add(root);

        //如果栈不为空，说明还有节点未遍历
        while(!stack.isEmpty()) {
            TreeNode node = stack.poll();
            result.add(node);


            if(node.left!=null){
                stack.push(node.left);
            }
            //这里要先将右子树添加进栈，
            if(node.right!=null){
                stack.push(node.right);
            }
        }

        // 翻转链表
        Collections.reverse(result);
        for(TreeNode child : result){
            System.out.print(child.val+" ");
        }
    }