二叉树的前序、中序、后序遍历——递归与非递归

Java基础 数据结构

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。
因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。

一.前序遍历

前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。

递归实现

  public void prefix(TreeNode root) {
        if (root != null) {
            System.out.println(root.val);
            prefix(root.left);
            prefix(root.right);
        }
    }

非递归实现

根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：
对于任一结点node：

 1)访问结点node，并将结点node入栈;

 2)判断结点node的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将node的左孩子置为当前的结点node;

 3)直到node为NULL并且栈为空，则遍历结束。

public void prefix2(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                System.out.println(root.val);
                stack.push(root);
                root = root.left;
            }
            if (!stack.isEmpty()) {
                TreeNode temp = stack.pop();
                root = temp.right;
            }
        }
    }

二.中序遍历
　　中序遍历按照“左孩子-根结点-右孩子”的顺序进行访问。
　　

递归实现

public void infix(TreeNode root) {
        if (root != null) {
            infix(root.left);
            System.out.println(root.val);
            infix(root.right);
        }
    }

非递归实现

根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

　　对于任一结点node，

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

　 2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的node置为栈顶结点的右孩子；

　3)直到node为NULL并且栈为空则遍历结束。

 public void infix2(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            if (!stack.isEmpty()) {
                TreeNode temp = stack.pop();
                System.out.println(temp.val);
                root = temp.right;
            }
        }
    }

三.后序遍历

  　后序遍历按照“左孩子-右孩子-根结点”的顺序进行访问。

递归实现

 public void suffix(TreeNode root) {
        if (root != null) {
            suffix(root.left);
            suffix(root.right);
            System.out.println(root.val);
        }
    }

非递归实现

后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。

  第一种思路：对于任一结点node，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问， 因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就 保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是 否是第一次出现在栈顶。

      private class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        boolean isFirst; // 针对后序遍历
        TreeNode(int x) { val = x; }
    }

public void suffix2(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) { // 先遍历左结点
                root.isFirst = true; // 第一次遍历，此时不知道左右结点是否被访问
                stack.push(root);
                root = root.left;
            }
            if (!stack.isEmpty()) {
                TreeNode temp = stack.pop(); //
                if (temp.isFirst == true) { // 第一次出现在栈顶，说明右子树还没遍历
                    temp.isFirst = false;
                    stack.push(temp);
                    root = temp.right; // 遍历右子树
                } else { // 否则，第二次出现在栈顶，左右子树都访问过
                    System.out.println(temp.val); // 访问该结点
                    root = null;
                }
            }
        }
    }

第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。
①如果node不存在左孩子和右孩子，则可以直接访问它；
②或者node存 在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
若非上述两种情况，则将node的右孩子和左孩子依次入栈(入栈顺序先右再左)，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

public void suffix3(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        // 先左再右 最后根
        TreeNode preVisitNode = null;
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode temp = stack.peek();
            if ((temp.left == null && temp.right == null)// 左右都为空，则直接访问该结点
                    || (preVisitNode != null &&(preVisitNode == temp.left || preVisitNode == temp.right))) { //左右都被访问过了，直接访问该结点
                System.out.println(stack.pop().val);
                preVisitNode = temp;
            } else {
                if (temp.right != null) {
                    stack.push(temp.right);
                }
                if (temp.left != null) {
                    stack.push(temp.left);
                }
            }
        }
    }

三.层序遍历

非递归实现

使用一个队列来存储访问顺序。从上到下，从左到右。

public void level(TreeNode root) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.push(root);
        while (!queue.isEmpty()) {
            TreeNode temp = queue.pop();
            System.out.println(temp.val);
            if(temp.left != null) queue.push(temp.left);
            if(temp.right != null) queue.push(temp.right);
        }
    }