二叉树的遍历

二叉树的两种遍历:

递归版：

    /**
     * 先序遍历
     *
     * @param head
     */
    public static void preOrder(Node head) {
        if (head == null) return;
        System.out.print(head.value + " ");
        preOrder(head.left);
        preOrder(head.right);
    }

    /**
     * 中序遍历
     *
     * @param head
     */
    public static void inOrder(Node head) {
        if (head == null) return;
        inOrder(head.left);
        System.out.print(head.value + " ");
        inOrder(head.right);
    }

    /**
     * 后序遍历
     *
     * @param head
     */
    public static void postOrder(Node head) {
        if (head == null) return;
        postOrder(head.left);
        postOrder(head.right);
        System.out.print(head.value + " ");
    }

非递归版：

    /**
     * 先序遍历 非递归版
     * 思路：
     * 使用辅助栈，如果头结点不为空，则直接将头结点压入栈中
     * 循环判断栈是否为空，不为空则弹出栈顶结点，打印，再将头结点的右子结点压入栈中，再将头结点的左子结点压入栈中
     *
     * @param head
     */
    public static void preOrderUnRecur(Node head) {
        if (head != null) {
            Stack<Node> stack = new Stack<>();
            stack.push(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);
            }
        }
        System.out.println();
    }

    /**
     * 中序遍历非递归版
     * 思路：
     * 如果头结点不为空，或者当前栈不为空
     * 那么循环压入头结点的，再将头结点的指针指向头结点的左子结点，（一直压入左子结点，直到没有子结点可以继续）
     * 否则弹出栈顶元素，并打印，然后压入当前结点的右子结点
     *
     * @param head
     */
    public static void inOrderUnRecur(Node head) {
        if (head != null) {
            Stack<Node> stack = new Stack<>();
            while (head != null || !stack.isEmpty()) {
                if (head != null) {
                    stack.push(head);
                    head = head.left;
                } else {
                    head = stack.pop();
                    System.out.print(head.value + " ");
                    head = head.right;
                }
            }
        }
        System.out.println();
    }


    /**
     * 后序遍历非递归版
     * 1 2 4 3 6 7 9 11 10 8 5
     * 思路：
     * 两个辅助栈，参照先序遍历非递归版
     * 先序遍历压栈顺序：中，右，左
     * 后序遍历压栈顺序：中，左，右
     *
     * @param head
     */
    public static void posOrderUnRecur(Node head) {
        if (head != null) {
            Stack<Node> stack1 = new Stack<>();
            Stack<Node> 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()) {
                head = stack2.pop();
                System.out.print(head.value + " ");
            }
        }
        System.out.println();
    }

测试代码：

// 结点类型
public static class Node {
        public int value;
        public Node left;
        public Node right;

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

	// 测试方法
    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);
        
        //递归版
        preOrder(head);
//        inOrder(head);
//        postOrder(head);
        System.out.println();
        //非递归版
        preOrderUnRecur(head);
//        inOrderUnRecur(head);
//        posOrderUnRecur(head);
    }