结合入栈出栈浅谈前序遍历，中序遍历，后序遍历

二叉树深度遍历

讨巧应付面试

以前其实也懂什么叫二叉树的前中后序遍历，反正面试的时候，给我一个二叉树，我是知道怎么写出他们的答案的，例如如下二叉树

• 前序遍历：A,B,D,E,C,F,G
• 中序遍历：D,B,E,A,F,C,G
• 后序遍历：D,E,B,F,G,C,A

这是他们三个的结果，然后我再说一下怎么来的，我的诀窍就是从根节点开始先找左节点，然后没有左节点，再找右节点，如果右节点也找完了，然后返回上一级，只不过前序遍历是第一次访问该节点就打印一下这个节点，中序遍历是第二次访问的时候打印，后续遍历的是第三次访问的时候打印。

前序遍历

先访问A，打印A。继续找左节点
访问B，打印B，继续找左节点
访问D，打印D，继续找左节点，D没有左节点，找右节点，也没有，返回上一级B的右节点
访问E，打印E，E没有左节点，然后也没有右节点，向上找，找到了A， 访问A的右节点，
访问C，打印C，继续找左节点
访问F，打印F，继续找左节点，F没有左节点，找右节点，也没有，返回上一级C的右节点
访问G，打印G

中序遍历

先访问A，不打印，记录一次访问记录，继续找左节点
访问B，不打印，记录一次访问记录，继续找左节点
访问D，不打印，继续找左节点，没有，返回到D，说明D访问了两次了，打印D，
返回B，第二次访问，打印B，找右节点
访问E，不打印，记录一次访问记录，继续找左节点，没有，返回，打印E，
返回到A，A第二次访问，打印A
…

后续遍历

类似,只不过后续遍历是第三次访问的时候才打印
反正这种方法面试的时候，足够，不就是让我说出来顺序吗？

程序设计

后来自己就想，如果自己写一个程序来深度遍历一下该怎么前序遍历呢。画了出栈入栈图如下：

前序遍历

拿到节点A，然后打印节点A，然后放入栈，在访问左节点B，打印B，然后放入B，再访问D节点，打印D节点，D节点入栈
D节点是叶子节点，出栈，然后B节点继续出栈，找B的右节点E，打印E，E入站，E是叶子节点，出栈，
A节点出栈，获取右节点C，打印C,C入栈,找到C的左节点F，打印F，F入栈，F是叶子节点，F出栈，
C节点出栈，找到右节点G，打印G，G入站， G是叶子节点，出栈。

按照上边的顺序是 A,B,D,E,C,F,G,是不是就是入站前的打印，程序如下：

static class Node{

        public Node(String node) {
            this.node = node;
        }

        public String node;

        public Node leftChild;

        public Node rightChild;

        @Override
        public String toString() {
            return "Node{" +
                    "node='" + node + '\'' +
                    '}';
        }
    }
    
    public static void preDfs(Node root){
        if (root == null){
            return;
        }
        System.out.println(root.node);
        preDfs(root.leftChild);
        preDfs(root.rightChild);
    }
    
    public static void main(String[] args) {
        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");
        a.leftChild = b;
        a.rightChild = c;
        b.leftChild = d;
        b.rightChild = e;
        c.leftChild = f;
        c.rightChild = g;
        preDfs(a);
    }

以前总是不懂，为什么preDfs(root.leftChild); preDfs(root.rightChild);这两行代码能够实现深度遍历，理解了出栈入栈就明白了。

中序遍历

理解了前序遍历，再来理解一下中序遍历，按照我讨巧的方法，就是第二次访问，那么第一次访问就是入站，第二次是不是就是出栈呢，试一下。还是用上边的图。

访问A节点，A节点入栈，访问左节点B，B节点入栈，访问B的左节点D，D节点入栈，D是叶子节点，出栈，打印D，B出栈，打印B，访问B的右节点E，E入栈，叶子节点直接出栈，打印E,A节点出栈，打印A，找到A的右节点C入栈，找到C的左节点F入栈,因为F是叶子节点出栈，打印F，C节点出栈，打印C，G节点入栈出栈，打印G
最后的结果就是D，B，E，A，F，C，G
其实中序遍历就是先访问当前节点的左节点，如果左节点访问结束，才访问当前节点，但是叶子节点没有子节点，所以我就直接打印了。但是如果要访问左节点，就需要把当前的节点入栈，然后去访问下一个节点，然后再出栈。

    public static void inOrderDfs(Node root){
        if (root == null){
            return;
        }
        inOrderDfs(root.leftChild);
        System.out.print(root.node);
        inOrderDfs(root.rightChild);
    }

后序遍历

后续遍历其实是先遍历当前节点的左右节点，等左右节点都访问完了再访问当前节点，这就有一个问题，访问左节点是一个方法，访问右节点一个防范，这就涉及到两次入栈，那就是需要两次出栈。

A入栈，B入栈，D入栈，D是叶子节点，出栈打印D，B出栈，B入栈，E入栈，E是叶子节点，打印E,B出栈，打印B,A出栈，A入栈，C入栈，F入栈，F出栈打印，C出栈，C入栈，F入栈出栈，打印F，C出栈，C入栈，G入栈，G出栈打印，C出栈打印，A出栈打印，最后的结果就是D，E，B，F，G，C，A

public static void lastDfs(Node root){
        if (root == null){
            return;
        }
        lastDfs(root.leftChild);
        lastDfs(root.rightChild);
        System.out.print(root.node);
    }

最后总结就是前序遍历是出栈0次，中序遍历就是出栈1次，后续遍历就是出栈两次。