数据结构：二叉树的非递归遍历--详细分析与实现

假设有如图所示的一棵二叉树，我们分别对其前序、中序、后序以及层序进行非递归遍历。

• 前提：二叉树采用孩子表示法

class Node {
    Node left = null;//指向左子树
    Node right = null;//只指向右子树
    int val;

    public Node(int val){
        this.val=val;
    }
}

① 前 序 非 递 归 ：根→ 左子树 → 右子树

【方法1】

• 思路分析： 借助栈“ 先进后出 ”的特性。 （与层序遍历相似）

  1.空树---->直接返回
  2.非空--->让根先入栈
  3.如果队列栈不为空,循环执行以”下操作<一
      a.取栈顶元素---cur.peek()
      b.遍历该该元素
      c.删除栈顶元素
      d.如果当前节点有右子树，将右子树入栈
      e.如果当前节点有左子树，将左子树入栈
  

代码如下：

public void preOrder1(){
        if (root == null) {
            return;
        }

        Stack<Node> stack = new Stack<>();
        stack.push(root);
        System.out.println();
        System.out.print("非递归前序遍历1：");
        while (!stack.empty()){
            Node cur = stack.peek();
            System.out.print(cur.val+ " ");
            stack.pop();

            if(cur.right!=null){
                stack.push(cur.right);
            }

            if(cur.left!=null){
                stack.push(cur.left);
            }
        }
        System.out.println();
    }

【方法2】

• 思路分析：沿着根的左子树向下遍历

1、根左右：根入栈 栈不为空 删除栈顶元素

2、顺着跟沿左子树向下遍历 遇到右子树 右子树保存入栈

3、当左边遍历完 cur=stack.peek 从栈顶元素开始又想左遍历

                     1
                   /  \
                 2     5
                / \    / \
               3   4  6   7  

【解释说明】

• 先顺着根的左向下遍历， 根的右子树5入栈 ，然后2的右子树4入栈； 123遍历完后取栈顶元素4遍历， 4没有左子树；然后取栈顶元素5 遍历 5 6 ； 把7保存到栈 最后遍历7。

代码如下：

public void preOrder2(){
        if (root == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        System.out.print("非递归前序遍历2：");
        while (!stack.empty()) {
            Node cur = stack.peek();//获取栈顶元素（保存的右子树节点）
            stack.pop();

            while (cur!=null){
                //顺着cur左侧一直向下遍历
                System.out.print(cur.val + " ");

                //将右子树保存起来
                if(cur.right!=null){
                    stack.push(cur.right);
                }
                cur=cur.left;
            }
        }
    }

② 中 序 非 递 归 ：左子树 → 根 → 右子树

• 思路分析： 后递归的先退出----栈

（1）、 先找到以root为根的二叉树中最左侧的节点，并保存所经路径中所有的节点 Node cur = root：

             while(cur){
               s.push(cur);
               cur=cur -> left;
             }

（2） cur为空：cur对应的树已遍历完
获取栈顶元素x,此时x的左子树为空，可认为x的左子树已遍历结束；

遍历当前根节点：
          cur = s.peek();
          sout(cur.val);
          s.pop();

（3) 遍历cur的右子树：

  null----不处理
  非空 cur=cur.right

不管cur的右子树是否存在，将其当成一棵新的二叉树遍历。

代码如下：

public void inOrderNor() {
        if (root == null) {
            return;
        }

        Node cur = root;
        Stack<Node> stack = new Stack<>();
        System.out.println();
        System.out.print("非递归中序序遍历：");

        while (cur!=null||!stack.empty()){
            //找以root为根的二叉树最左侧的节点，并保存到所经路径中所有节点----栈
            while (cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            //cur为空,认为该树已遍历完
            //可以遍历cur的根节点，cur的根节点次数在栈顶
            cur = stack.peek();
            System.out.print(cur.val+" ");
            stack.pop();

            //以cur为根的二叉树：左子树已经遍历完，根节点已经遍历完，剩余右子树没有遍历
            cur=cur.right;
        }
    }

③ 后 序 非 递 归 ：左子树 → 右子树 → 根

• 思路分析：

（1）找到以cur为根节点的二叉树最左侧的节点，并保存所经路径中的所有节点；

 while(cur){
            s.push(cur);
            cur=cur -> left;
        }

(2) 获取栈顶元素----获取子树的根节点

 Node top = s.peek();

(3) 遍历右子树

• 【注意】：为了防止出现死循环问题，我们必须要设置一个标志，来判断top的右子树是否已经遍历过（如果没有此操作，4的右子树6将会一直循环）

代码如下：

 public void postOrderNor() {
        if(root==null){
            return;
        }

        System.out.println();
        System.out.print("非递归后序遍历：");
        Stack<Node> s = new Stack<>();
        Node cur = root;
        Node flag = null;//标记刚刚遍历过的节点
        while (cur!=null || !s.empty()){
            // 找以cur为根的二叉树最左侧的节点，并保存到所经路径中所有节点----栈
            while (cur!=null){
                s.push(cur);
                cur=cur.left;
            }
            //获取cur子数的根
            Node top = s.peek();
            //top的右子树为空 || top的右子树已经遍历完成 （4的右子树6已经遍历，避免重复循环）
            if(top.right==null || top.right==flag){
                System.out.print(top.val + " ");
                flag=top;
                s.pop();
            }else{
                cur=top.right;
            }
        }
    }

④ 层序遍历 ：1 2 4 3 5 6

• 思路分析 ： 【队列】

  1.空树---->直接返回
  2.非空—>让根先入队列
  3.如果队列不为空,循环执行以下操作：
  （1）、去队头元素
  （2）、遍历该节点
  （3）、如果当前节点有左子树，将左子树入队列
  （4）、如果当前节点有右子树，将右子树入队列

代码如下：

 private void ceng(Node root){
        if(root == null){
            return;
        }
        Queue<Node> queue = new LinkedList<>() ;
        queue.offer(root);
        while (!queue.isEmpty()){
           Node cur = queue.poll();
            System.out.print(cur.val+" ");

            if(cur.left!=null){
                queue.offer(cur.left);
            }
            if(cur.right!=null){
                queue.offer(cur.right);
            }
        }
    }
   
    //一般情况下，树的根节点是不能随便告诉去其他
      人的，参数能不传递就尽量不传递
     public void ceng(){
       System.out.print("层序遍历：");
       ceng(root);
     }