二叉树的三种遍历的递归和非递归的总结（详细，有推导）java

之前已经总结过二叉树的层序遍历：

https://blog.csdn.net/u012156116/article/details/79393851

今天来探讨下二叉树的三种常见遍历的 递归，非递归 过程，其中非递归的推导过程可见最后的图：

1. 先序

1.1 递归

三种遍历方式的递归算法大同小异，只是打印节点的位置不一样，很简洁。

    public void pre_traversal_1(TreeNode node){
        if(node==null){
            return;
        }
        System.out.println(node.val);
        pre_traversal_1(node.left);
        pre_traversal_1(node.right);
    }

1.1 非递归

先序遍历方式的非递归算法过程如下：

首先新建一个栈st，一个记录当前节点的指针 pCur， 一个保存每次出栈节点的指针 work；

对于任一节点P，

1）输出节点P，然后将其入栈，再看P的左孩子是否为空；

2）若P的左孩子不为空，则置P的左孩子为当前节点，重复1）的操作；

3）若P的左孩子为空，则将栈顶节点出栈，但不输出，并将出栈节点的右孩子置为当前节点，看其是否为空；

4）若不为空，则循环至1）操作；

5）如果为空，则继续出栈，但不输出，同时将出栈节点的右孩子置为当前节点，看其是否为空，重复4）和5）操作；

6）直到当前节点P为NULL并且栈空，遍历结束。

    public void pre_traversal_2(TreeNode node){
        Stack<TreeNode> st = new Stack<>();
        TreeNode pCur = node;                      // 当前节点
        TreeNode work;                             // 保存每次出栈节点
        while(pCur!=null || !st.isEmpty()){
            System.out.println(pCur.val);
            st.push(pCur);
            pCur = pCur.left;
            while(pCur==null && !st.isEmpty()){
                work = st.pop();
                pCur = work.right;
            }
        }
    }

2. 中序

2.1 递归

    public void mid_traversal_1(TreeNode node){
        if(node==null){
            return;
        }
        mid_traversal_1(node.left);
        System.out.println(node.val);
        mid_traversal_1(node.right);
    }

2.2 非递归

中序遍历的非递归算法跟先序的类似，不过是在每次弹出栈中节点时打印节点值。

对于任一节点P，

1）若P的左孩子不为空，则将P入栈并将P的左孩子置为当前节点，然后再对当前节点进行相同的处理；

2）若P的左孩子为空，则输出P节点，而后将P的右孩子置为当前节点，看其是否为空；

3）若不为空，则重复1）和2）的操作；

4）若为空，则执行出栈操作，输出栈顶节点，并将出栈的节点的右孩子置为当前节点，看起是否为空，重复3）和4）的操作；

5）直到当前节点P为NULL并且栈为空，则遍历结束。

    public void mid_traversal_2(TreeNode node){
        Stack<TreeNode> st = new Stack<>();
        TreeNode work; // 保存弹出栈的节点
        TreeNode pCur = node;  // 当前节点
        while(pCur!=null || !st.isEmpty()){
            if(pCur!=null){
                st.push(pCur);
                pCur = pCur.left;
            }else {
                while (pCur==null && !st.isEmpty()){
                    work = st.pop();
                    System.out.println(work.val);
                    pCur = work.right;
                }
            }
        }
    }

3. 后序

3.1 递归

    public void beh_traversal_1(TreeNode node){
        if(node==null){
            return;
        }
        beh_traversal_1(node.left);
        beh_traversal_1(node.right);
        System.out.println(node.val);
    }

3.2 非递归

后序遍历的非递归算法比较麻烦，跟之前有所不同，需要一个额外的指针pre指向上次打印的节点，如果一个节点没有左右孩子，那么打印，如果一个节点的左右孩子都已经打印过，那么这个节点也可以打印。而新家的pre指针就是用来判断左右孩子有没有被打印过的。

对于任一节点P，

1）先将节点P入栈；

2）若P不存在左孩子和右孩子，或者P存在左孩子或右孩子，但左右孩子已经被输出，则可以直接输出节点P，并将其出栈，将出栈节点P标记为上一个输出的节点，再将此时的栈顶结点设为当前节点；

3）若不满足2）中的条件，则将P的右孩子和左孩子依次入栈，当前节点重新置为栈顶结点，之后重复操作2）；

4）直到栈空，遍历结束。

    public void beh_traversal_2(TreeNode node){
        Stack<TreeNode> st = new Stack<>();
        if(node!=null){
            st.push(node);
        }
        TreeNode pCur;                             // 保存栈顶节点
        TreeNode pre=null;                         // 保存上一次弹出的节点
        while(!st.isEmpty()){
            pCur = st.peek();
            if((pCur.right == null && pCur.left == null) || pre!=null&&(pre==pCur.left||pre==pCur.right)){
                pre = st.pop();
                System.out.println(pre.val);
            }else{
                if (pCur.right!=null){
                    st.push(pCur.right);
                }
                if (pCur.left!=null){
                    st.push(pCur.left);
                }
            }
        }
    }

每种非递归的详细过程如下图：