二叉树的非递归遍历

前面已经介绍过二叉树的递归前序、中序和后序遍历，今天来介绍二叉树的非递归遍历写法。

1.前序、中序、后序的判别方式

1）根据遍历的根的位置：

根在前面：前序遍历（根-左-右）

根在中间：中序遍历（左-根-右）

根在后面：后序遍历（左-右-根）

2）根据第几次访问该结点：

第1次访问该结点：前序遍历

第2次访问该结点：中序遍历

第3次访问该结点：后序遍历

很明显，遍历的递归写法主要应用第一种判别方式，今天介绍的非递归写法应用的是第二种判别方式，运用栈和循环，难点在于怎么区分第几次访问，在访问的时候打印出数据。

2.非递归前序遍历

思路：每访问一个结点（第一次访问），只要该结点不为空，就把当前结点的值打印出来，并让该结点入栈（便于之后访问其右子树），同时继续访问其左孩子，直到左孩子为空；接着该访问左孩子为空的父结点的右子树（即栈顶元素的右子树），因此让栈顶元素出栈并记录下来，访问其右子树。只要当前结点不为空，就同样继续访问其左孩子。因此访问其左子树和右子树为一次循环。
当栈中元素不为空并且当前结点不为空时，说明把所有的根、根的左子树和根的右子树访问过了，循环终止。

    //非递归的前序遍历
    private static void preOrderNoR(Node root){
        Node cur=root;
        Stack<Node> stack=new Stack<>();
        while(!stack.isEmpty()||cur!=null) {
            //优先走左边
            while(cur!=null) {
                 System.out.print(cur.val+" ");
                 stack.push(cur);
                 cur = cur.left;
            }
            //从左走到头了，需要回溯
            //从栈里取出结点进行回溯
            //目前栈里所有结点的右子树都没有进行遍历
            Node top=stack.pop();
            cur=top.right;
        }
    }

3.非递归中序遍历

思路：每访问一个结点，就将其入栈，在让它出栈的时候为第二次访问，此时要打印。一个结点的整体访问过程和前序遍历一样，先让该结点入栈，然后访问它的左子树，直到左子树为空。此时要访问的就是当前结点的父结点的右子树，父结点出栈，记录下来，并打印父结点的值，继续访问右子树。终止条件和前序遍历相同。

   //非递归的中序遍历
    private static void inOrderNoR(Node root){
        Node cur=root;
        Stack<Node> stack=new Stack<>();
        while(!stack.isEmpty()||cur!=null) {
            //优先走左边
            while(cur!=null) {
                stack.push(cur);
                cur = cur.left;
            }
            //从左走到头了，需要回溯
            //从栈里取出结点进行回溯
            //目前栈里所有结点的右子树都没有进行遍历
            Node top=stack.pop();
            //top取出的结点，是第二次遇到该结点
            System.out.print(top.val+" ");
            cur=top.right;
        }
    }

4.非递归后序遍历

思路：第三次访问该结点就是在访问过其右子树后时的访问。此时，右子树的情形有两种，右子树为空或者右子树为上次完整访问过的结点。和前序遍历、中序遍历不同的是要设置一个last，用来记录上次被完整遍历过的树的根结点。每访问一个结点，仍然要先将该结点放入栈中，遍历其左子树，直到左子树为空。如果当前结点的右子树为上面分析的两种情形，则打印出当前结点的值，并出栈，设置栈顶元素为last。如果不是，则访问当前结点的右子树。继续循环，直到栈为空并且当前结点为空。

    //非递归的后序遍历
    private static void postOrderNoR(Node root){
        Node cur=root;
        Node last=null;//上一次被完整遍历过的树的根结点
        Stack<Node> stack=new Stack<>();
        while(!stack.isEmpty()||cur!=null) {
            //优先走左边
            while(cur!=null) {
                stack.push(cur);
                cur = cur.left;
            }
            //从左走到头了，需要回溯
            //从栈里取出结点进行回溯
            //目前栈里所有结点的右子树都没有进行遍历
            Node top=stack.peek();
            if(top.right==null){
                System.out.print(top.val+" ");
                stack.pop();
                last=top;
            }else if(top.right==last){
                System.out.print(top.val+" ");
                stack.pop();
                last=top;
            }else{
                cur=top.right;
            }
        }

    }

测试创建的二叉树形态为：

测试代码为：

package com.xunpu.datastruct.tree;

public class TreeMethod {
    public static class Node{
        char val;//值
        Node left;//左子树
        Node right;//右子树
        Node(char val){
            this.val=val;
        }
    }

    private static Node buildSearchTree(){
        Node a=new Node('A');
        Node b=new Node('B');
        Node c=new Node('C');
        Node d=new Node('D');
        Node e=new Node('E');
        Node f=new Node('F');
        Node g=new Node('G');
        Node h=new Node('H');
        e.left=b;e.right=g;
        b.left=a;b.right=d;
        d.left=c;
        g.left=f;g.right=h;
        return e;
    }
    public static void main(String[] args) {
        Node root=buildSearchTree();
        System.out.print("前序遍历为：");
        preOrderNoR(root);
        System.out.println();
        System.out.print("中序遍历为：");
        inOrderNoR(root);
        System.out.println();
        System.out.print("后序遍历为：");
        postOrderNoR(root);
    }
}

结果为：