面试必考01——二叉树的前中后遍历

实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式

import java.util.Stack;

//二叉树的前序、中序、后序遍历(递归和非递归方法)
//二叉树的层次遍历(只有非递归的方法)

public class T01PreInPostOrder {

    public static class Node {
        public int value;
        public Node left;
        public Node right;

        public Node(int data) {
            this.value = data;
        }
    }

    public static void preOrder(Node head) {
        if (head == null) {
            return;
        }
        System.out.print(head.value + " ");
        preOrder(head.left);
        preOrder(head.right);
    }

    public static void inOrder(Node head) {
        if (head == null) {
            return;
        }
        inOrder(head.left);
        System.out.print(head.value + " ");
        inOrder(head.right);
    }

    public static void postOrder(Node head) {
        if (head == null) {
            return;
        }
        postOrder(head.left);
        postOrder(head.right);
        System.out.print(head.value + " ");
    }

    /**
     * 先序遍历
     * 往栈中压入根结点
     * 弹出栈中一个结点并打印
     * 压入刚弹出结点的右结点和左结点
     * 弹出栈中一个结点并打印
     */
    public static void preOrderNR(Node head) {
        if (head != null) {
            Stack<Node> stack = new Stack<>();
            stack.push(head);
            Node res = null;
            while (!stack.isEmpty()) {
                res = stack.pop();
                System.out.print(res.value + " ");
                if (res.right != null) {
                    stack.push(res.right);
                }
                if (res.left != null) {
                    stack.push(res.left);
                }
            }
        }
    }

    /**
     * 中序遍历
     * 当前结点不为空时，压入当前结点，当前结点指针向它左结点移动
     * 当前结点为空、栈不为空时，弹出栈结点并打印，当前结点指针向栈结点的右结点移动
     */
    public static void inOrderNR(Node head) {
        if (head != null) {
            Stack<Node> stack = new Stack<>();
            Node cur = head;
            while (!stack.isEmpty() || cur != null) {
                if (cur != null) {
                    stack.push(cur);
                    cur = cur.left;
                } else {
                    cur = stack.pop();
                    System.out.print(cur.value + " ");
                    cur = cur.right;
                }
            }
        }
    }

    /**
     * 后序遍历
     * 由前面的先序遍历，中左右，改为中右左，然后放入栈中逆序，得到左右中，即后序遍历
     */
    public static void postOrderNR(Node head) {
        if (head != null) {
            Stack<Node> s1 = new Stack<>();
            Stack<Node> s2 = new Stack<>();
            s1.push(head);
            Node res = null;
            while (!s1.isEmpty()) {
                res = s1.pop();
                s2.push(res);
                if (res.left != null) {
                    s1.push(res.left);
                }
                if (res.right != null) {
                    s1.push(res.right);
                }
            }
            while (!s2.isEmpty()) {
                System.out.print(s2.pop().value + " ");
            }
        }
    }

    public static void main(String[] args) {
        Node head = new Node(5);
        head.left = new Node(3);
        head.right = new Node(8);
        head.left.left = new Node(2);
        head.left.right = new Node(4);
        head.left.left.left = new Node(1);
        head.right.left = new Node(7);
        head.right.left.left = new Node(6);
        head.right.right = new Node(10);
        head.right.right.left = new Node(9);
        head.right.right.right = new Node(11);

        // recursive
        System.out.println("==============recursive==============");
        System.out.print("pre-order: ");
        preOrder(head);
        System.out.println();
        System.out.print("in-order: ");
        inOrder(head);
        System.out.println();
        System.out.print("post-order: ");
        postOrder(head);
        System.out.println();

        // unrecursive
        System.out.println("============unrecursive=============");
        System.out.print("pre-order: ");
        preOrderNR(head);
        System.out.println();
        System.out.print("in-order: ");
        inOrderNR(head);
        System.out.println();
        System.out.print("post-order: ");
        postOrderNR(head);
        System.out.println();
    }
}