二叉树递归及非递归遍历

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * 二叉树递归及非递归遍历
 * 
 * @author 过路的守望
 *
 */
public class BinaryTree {

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);
        Node node8 = new Node(8);
        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;
        node4.left = node8;
        BinaryTree br = new BinaryTree();
        /*
         * br.preTraverseRec(node1); 
         * br.preTraverse(node1);
         */
        /* br.inTraverseRec(node1); */
        /* br.inTraverse(node1); */
        /* br.postTraverseRec(node1); */
        /* br.postTraverse(node1); */
        br.levelTraverse(node1);
    }

    /*
     * 递归先序遍历二叉树 先序遍历: 先打印父亲节点，再处理左子树，处理完左子树后再处理右子树。
     */
    private void preTraverseRec(Node parent) {
        /*
         * 只有节点非空时才进行处理
         */
        if (parent != null) {
            System.out.println(parent.value);
            preTraverseRec(parent.left);
            preTraverseRec(parent.right);
        }
    }

    /*
     * 非递归先序遍历二叉树 非递归先序遍历： 可借助栈特性实现
     */
    private void preTraverse(Node parent) {
        if (parent == null) {
            return;
        }
        Stack<Node> stack = new Stack<BinaryTree.Node>();
        /*
         * 记录当前处理的节点
         */
        stack.push(parent);
        Node cur = null;
        while (!stack.isEmpty()) {
            cur = stack.pop();
            System.out.println(cur.value);
            /*
             * 由于栈是先进后出的故先将右儿子压栈
             */
            if (cur.right != null) {
                stack.push(cur.right);
            }
            if (cur.left != null) {
                stack.push(cur.left);
            }
        }
    }

    /*
     * 递归中序遍历二叉树 中序遍历： 先处理左儿子，再处理父亲节点，然后处理右儿子
     */
    private void inTraverseRec(Node parent) {
        if (parent != null) {
            inTraverseRec(parent.left);
            System.out.println(parent.value);
            inTraverseRec(parent.right);
        }
    }

    /*
     * 非递归中序遍历二叉树
     */
    private void inTraverse(Node parent) {
        if (parent == null) {
            return;
        }
        Stack<Node> stack = new Stack<BinaryTree.Node>();
        Node cur = parent;
        while (!stack.isEmpty() || cur != null) {
            /*
             * 访问到最左儿子
             */
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            /*
             * 打印最左儿子
             */
            cur = stack.pop();
            System.out.println(cur.value);
            /*
             * 处理右儿子
             */
            cur = cur.right;
        }

    }

    /*
     * 递归后序遍历二叉树 后序遍历： 先处理左儿子，再处理右儿子，在处理父节点
     */
    private void postTraverseRec(Node parent) {
        if (parent != null) {
            postTraverseRec(parent.left);
            postTraverseRec(parent.right);
            System.out.println(parent.value);
        }
    }

    private void postTraverse(Node parent) {
        if (parent == null) {
            return;
        }
        Stack<Node> stack = new Stack<BinaryTree.Node>();
        /*
         * 当前处理节点
         */
        Node cur = parent;
        /*
         * 前一个处理的节点
         */
        Node pre = null;
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();
            /*
             * 当前节点的右节点为空或则已经遍历过，打印当前节点
             */
            while (cur.right == null || cur.right == pre) {
                System.out.println(cur.value);
                pre = cur;
                stack.pop();
                if (stack.isEmpty()) {
                    return;
                }
                cur = stack.peek();
            }
            /*
             * 处理右儿子
             */
            cur = cur.right;
        }
    }

    /*
     * 二叉树层序遍历 基于队列实现
     */
    private void levelTraverse(Node parent) {
        if (parent == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<BinaryTree.Node>();
        queue.offer(parent);
        Node cur = parent;
        /*
         * 处理完当前层后再处理下一层
         */
        while (!queue.isEmpty()) {
            cur = queue.poll();
            System.out.println(cur.value);
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }

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

        private Node() {

        }

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

        public Node getLeft() {
            return left;
        }

        public Node getRight() {
            return right;
        }

        public int getValue() {
            return value;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public void setRight(Node right) {
            this.right = right;
        }

        public void setValue(int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "Node [value=" + value + ", left=" + left + ", right="
                    + right + "]";
        }
    }
}