面试题2——遍历二叉树

题目

用先序，中序，后序，分别遍历一个二叉树

思想

1.（递归法）利用递归思想，向左向右遍历一个二叉树

2.（非递归）利用栈和循环，将结点压栈，按不同遍历方式选择不同策略从栈中取出结点输出

PS：后序遍历思想，从根结点开始，将所有最左结点全部压栈，每当一个结点出栈时，都先扫描该结点的右子树，只有当一个结点的左孩子和右孩子结点均被访问过了，才能访问结点自身。（判断当右孩子输出时，则向上回溯）

前序递归遍历算法：访问根结点-->递归遍历根结点的左子树-->递归遍历根结点的右子树

中序递归遍历算法：递归遍历根结点的左子树-->访问根结点-->递归遍历根结点的右子树

后序递归遍历算法：递归遍历根结点的左子树-->递归遍历根结点的右子树-->访问根结点

实现

二叉树结点 BinaryTreeNode.java

//二叉树节点
public class BinaryTreeNode {
    public int data;
    public BinaryTreeNode left;
    public BinaryTreeNode right;

    public BinaryTreeNode(int data, BinaryTreeNode left, BinaryTreeNode right){
        super();
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

遍历 BinaryTreeTraversing.java

package lms.datastructure.tree;

import javafx.scene.transform.Rotate;

import java.util.Stack;

//遍历二叉树
public class BinaryTreeTraversing {
    /**
                 1
                /  
                2    3
               /   / 
              4  5  6  7
              /  
             8    9
                   
                   10
     */

    //====先序遍历=========
    //递归 先序
    public static void preOrderRecur(BinaryTreeNode root) {
        if (null != root) {
            System.out.print(root.data + " ");
            preOrderRecur(root.left);
            preOrderRecur(root.right);
        }
    }

    //非递归 先序
    public static void preOrder(BinaryTreeNode root) {
        Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
        while (true) {
            while (root != null) {
                System.out.print(root.data + " ");
                stack.push(root);
                root = root.left;
            }
            if (stack.isEmpty()) break;
            root = stack.pop();
            root = root.right;
        }
    }

    //=====中序遍历============
    //递归 中序
    public static void inOrderRecur(BinaryTreeNode root) {
        if (null != root) {
            inOrderRecur(root.left);
            System.out.print(root.data + " ");
            inOrderRecur(root.right);
        }
    }

    //中序遍历 非递归
    public static void inOrder(BinaryTreeNode root) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        while (true) {
            //循环，遍历左边
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            if (stack.isEmpty()) break;
            //无右叶子的时候，从栈中弹出
            root = stack.pop();
            System.out.print(root.data + " ");
            //无右叶子的时候，从栈中弹出
            root = root.right;
        }
    }

    //=====后序遍历============
    //递归 后序
    public static void postOrderRecur(BinaryTreeNode root) {
        if (null != root) {
            postOrderRecur(root.left);
            postOrderRecur(root.right);
            System.out.print(root.data + " ");
        }
    }

    //非递归 后序（核心思想：每次左子树遍历完之后，每一步判断是否右子树为null，不为null指针移动到右子树上继续进行 “左->右->根” 步骤）
    public static void postOrder(BinaryTreeNode root) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        while (true) {
            if (null != root) {
                stack.push(root);
                root = root.left;
            } else {
                if (stack.isEmpty()) return;
                //到叶子节点 判断如果是叶子节点（是否为右孩子结点），则输出
                if (null == stack.lastElement().right) {
                    root = stack.pop();
                    System.out.print(root.data + " ");
                    //右子树右叶子访问之后向上回溯
                    while (root == stack.lastElement().right) {
                        System.out.print(stack.lastElement().data + " ");
                        root = stack.pop();
                        //System.out.print(root.data + " ");
                        if (stack.isEmpty()) break;
                    }
                }

                //移动指针到节点的右子树上
                if (!stack.isEmpty()) {
                    root = stack.lastElement().right;
                } else {
                    //终止条件
                    root = null;
                }
            }
        }
    }

    public static void main(String[] args) {
        /**
                                 1
                                /  
                               2    3
                              /   / 
                             4  5  6  7
                               /  
                              8    9
                                    
                                    10
         */
        BinaryTreeNode node10 = new BinaryTreeNode(10, null, null);
        BinaryTreeNode node8 = new BinaryTreeNode(8, null, null);
        BinaryTreeNode node9 = new BinaryTreeNode(9, null, node10);
        BinaryTreeNode node4 = new BinaryTreeNode(4, null, null);
        BinaryTreeNode node5 = new BinaryTreeNode(5, node8, node9);
        BinaryTreeNode node6 = new BinaryTreeNode(6, null, null);
        BinaryTreeNode node7 = new BinaryTreeNode(7, null, null);
        BinaryTreeNode node2 = new BinaryTreeNode(2, node4, node5);
        BinaryTreeNode node3 = new BinaryTreeNode(3, node6, node7);
        BinaryTreeNode node1 = new BinaryTreeNode(1, node2, node3);

        System.out.println("====先序遍历====");
        preOrderRecur(node1);
        System.out.println("");
        System.out.println("====先序遍历非递归====");
        preOrder(node1);
        System.out.println("");
        System.out.println("====中序遍历====");
        inOrderRecur(node1);
        System.out.println("");
        System.out.println("====中序遍历非递归====");
        inOrder(node1);
        System.out.println("");
        System.out.println("====后序遍历====");
        postOrderRecur(node1);
        System.out.println("");
        System.out.println("====后序遍历非递归====");
        postOrder(node1);
        System.out.println("");
    }

}

 后序遍历——双栈法

后序遍历的顺序：左孩子 -> 右孩子 -> 根结点。打印每个结点需要访问根结点三次，先从根结点开始找到左孩子，返回再找到右孩子，再返回到根结点，需要访问根结点三次，直接按照当前顺序进行遍历不知如何下手，那么我们可以换一个角度去考虑。不妨借助一个栈先存储 根结点 -> 右孩子 -> 左孩子 的结果，再将其依次弹出就是后序遍历的顺序了。

将前序遍历的逻辑改写为：弹出每个栈顶结点作为当前结点并存储到一个辅助栈中，如果当前结点有左孩子就先压入左孩子，如果有右孩子就后压入右孩子，每次取栈顶弹出到辅助栈中。最后将得到的辅助栈中元素依次弹出得到的就是后序遍历的结果。

    //后序遍历 非递归 双栈法
    public static void postOrderTwoStack(BinaryTreeNode root) {
        Stack<BinaryTreeNode> stack1 = new Stack<>();    // 辅助栈，存储 根 -> 右 -> 左 的结果
        Stack<BinaryTreeNode> stack2 = new Stack<>();
        if (root != null) {
            stack1.push(root);
            while (!stack1.isEmpty()) {
                root = stack1.pop();
                stack2.push(root);
                if (root.left != null) {
                    stack1.push(root.left);            // 有左孩子就先压入左孩子
                }
                if (root.right != null) {
                    stack1.push(root.right);           // 有右孩子就后压入右孩子
                }
            }
            while (!stack2.isEmpty()) {
                System.out.print(stack2.pop().data + " ");     // 逆序打印 根 -> 右 -> 左 的结果，就是后序遍历的结果
            }
        }
    }

输出结果

====先序遍历====
1 2 4 5 8 9 10 3 6 7
====先序遍历非递归====
1 2 4 5 8 9 10 3 6 7
====中序遍历====
4 2 8 5 9 10 1 6 3 7
====中序遍历非递归====
4 2 8 5 9 10 1 6 3 7
====后序遍历====
4 8 10 9 5 2 6 7 3 1
====后序遍历非递归====
4 8 10 9 5 2 6 7 3 1