使用递归和非递归方式实现二叉树先序、中序、后序遍历

题目：

用递归和非递归方式，分别按照二叉树先序、中序和后续打印所有的节点。先序为根左右，中序为左根右，后序为左右根。

递归方式：

（1）先序：

    //先序 根左右
    public static void preOrderRecur(Node head) {
        if (head == null) {
            return;
        }
        System.out.println(head.value + " ");
        preOrderRecur(head.left);
        preOrderRecur(head.right);
    }

 （2）中序：

    //中序 左根右
    public static void inOrderRecur(Node head) {
        if (head == null) {
            return;
        }
        inOrderRecur(head.left);
        System.out.print(head.value + " ");
        inOrderRecur(head.right);
    }

（3）后序：

 

    //后序 左右根
    public static void postOrderRecur(Node head) {
        if (head == null) {
            return;
        }
        postOrderRecur(head.left);
        postOrderRecur(head.right);
        System.out.print(head.value + " ");
    }

测试结果：

    public static void main(String[] args) {
        Node head = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        Node node3 = new Node(4);
        Node node4 = new Node(5);
        Node node5 = new Node(6);

        head.left = node1;
        head.right = node2;
        node1.left = node3;
        node1.right = node4;
        node2.right = node5;

        preOrderRecur(head);
        System.out.println();
        inOrderRecur(head);
        System.out.println();
        postOrderRecur(head);
}

结果：

 非递归方式：

（1）先序：

具体过程如下：

（1）申请一个新的栈，记为stack，然后将头节点head压入栈中。

（2）从stack中弹出栈顶节点，记为cur，然后打印cur节点的值，再将节点cur的右孩子（不为空）入栈，最后将cur的左孩子（不为空的话）入栈。

（3）不断重复（2）过程，直到stack为空。

代码实现：

    //非递归先序
    public static void preOrderUnRecur(Node head) {
        System.out.print("非递归先序：");
        if (head != null) {
            Stack stack = new Stack<>();
            stack.add(head);
            while (!stack.isEmpty()) {
                head = stack.pop();
                System.out.print(head.value + " ");
                if (head.right != null) {
                    stack.push(head.right);
                }
                if (head.left != null) {
                    stack.push(head.left);
                }
            }
        }
    }

（2）中序：

具体过程如下：

（1）申请一个新的栈，记为stack，初始时，令变量cur=head。

（2）先把cur节点压入栈，对以cur节点为头节点的整颗子树来说，依次把左边界压入栈中，即不停的令 cur = cur.left，然后重复步骤（2）。

（3）不断重复步骤2，直到发现cur为空，此时从 stack 中弹出一个节点，记为 node，打印node的值，并且让 cur = node.right，（这里注意，让cur=node.right的时候，cur的值已经打印了，也就是根的值已经打印了，所以可以保证根在右前面打印）然后继续重复步骤2。

（4）当stack为空且cur为空时，整个过程停止。

 代码实现：

    //非递归中序
    public static void inOrderUnRecur(Node head) {
        System.out.print("非递归中序：");
        if(head != null) {
            Stack stack = new Stack<>();
            while (!stack.isEmpty() || head != null) {
                //先把左子树都放进栈
                if (head != null) {
                    stack.push(head);
                    head = head.left;
                } else {
                    head = stack.pop();
                    System.out.print(head.value + " ");
                    head = head.right;
                }
            }
        }
    }

（3）后序：

具体过程：

（1）申请一个栈记为 stack1，然后将头节点head压入stack1中。

（2）从stack1中弹出的节点记为cur，然后依次将cur的左孩子节点和右孩子节点压入stack1中。（先左后右）

（3）在整个过程中，每一个从stack1弹出的节点都放入 stack2中。

（4）不断重复（2）（3），直到s1为空，过程停止。

（5）从s2中依次弹出节点并打印，打印的顺序就是后序遍历的顺序。

每颗子树的头节点先从stack1弹出到stack2，然后把它的孩子从左到右压入到stack1，再从stack1中弹出的顺序就是先右再左，从stack1弹出的顺序就是 根 右 左，stack2与stack1相反，所以就是左右根。

 代码实现：

    //非递归后序
    public static void postOrderUnRecur(Node head) {
        System.out.print("非递归后序：");
        if (head != null) {
            Stack stack1 = new Stack<>();
            Stack stack2 = new Stack<>();
            stack1.push(head);
            while (!stack1.isEmpty()) {
                head = stack1.pop();
                stack2.push(head);
                if (head.left != null) {
                    stack1.push(head.left);
                }
                if (head.right != null) {
                    stack1.push(head.right);
                }
            }
            while (!stack2.isEmpty()) {
                System.out.print(stack2.pop().value + " ");
            }
        }
    }

测试结果：