Java实现二叉树的先序、中序、后序、层级遍历

// 递归先序遍历
    public static void PreOrderTraverse(BitNode root) {
        if (root != null) {
            visitTNode(root);
            PreOrderTraverse(root.lchild);
            PreOrderTraverse(root.rchild);
        }
    }

    // 递归中序遍历
    public static void InOrderTraverse(BitNode root) {
        if (root != null) {
            InOrderTraverse(root.lchild);
            visitTNode(root);
            InOrderTraverse(root.rchild);
        }
    }

    // 递归后序遍历
    public static void PostOrderTraverse(BitNode root) {
        if (root != null) {
            PostOrderTraverse(root.lchild);
            PostOrderTraverse(root.rchild);
            visitTNode(root);
        }
    }

// 非递归先序遍历
    public static void preorderTraverse(BitNode root) {
        Stack s = new Stack();
        s.push(root);
        while (!s.isEmpty()) {
            BitNode bn = (BitNode) s.pop();
            visitTNode(bn);
            if (bn.rchild != null)
                s.push(bn.rchild);
            if (bn.lchild != null)
                s.push(bn.lchild);
        }
    }

    // 非递归中序遍历
    public static void inorderTraverse(BitNode root) {
        Stack s = new Stack();
        BitNode p = root;
        while (p != null || !s.isEmpty()) {
            if (p != null) {
                s.push(p);
                p = p.lchild;
            } else {
                p = (BitNode) s.pop();
                visitTNode(p);
                p = p.rchild;
            }
        }
    }

    // 非递归后序遍历1
    public static void postorderTraverse(BitNode root) {
        Stack s = new Stack();
        BitNode p = root;
        // pre标记最近出栈的节点，用于判断是否是p节点的右孩子，如果是的话，就可以访问p节点
        BitNode pre = p;
        // flag标记是出栈还是继续将左孩子进栈
        boolean flag = true;
        while (p != null || !s.isEmpty()) {
            if (p != null && flag) {
                s.push(p);
                p = p.lchild;
            } else {
                if (s.isEmpty())
                    return;
                p = (BitNode) s.peek();
                if (p.rchild != null && p.rchild != pre) {
                    p = p.rchild;
                    flag = true;
                } else {
                    p = (BitNode) s.pop();
                    visitTNode(p);
                    flag = false;
                    pre = p;
                }
            }
        }
    }

    // 非递归后序遍历2
    public static void postorderTraverse2(BitNode root) {
        Stack s = new Stack();
        BitNode p = root;
        // pre标记最近出栈的节点，用于判断是否是p节点的右孩子，如果是的话，就可以访问p节点
        BitNode pre = p;
        while (p != null || !s.isEmpty()) {
            if (p != null) {
                s.push(p);
                p = p.lchild;
            } else {
                if (s.isEmpty())
                    return;
                p = (BitNode) s.peek();
                if (p.rchild != null && p.rchild != pre) {
                    p = p.rchild;
                } else {
                    p = (BitNode) s.pop();
                    visitTNode(p);
                    pre = p;
                    p = null;
                }
            }
        }
    }

    // 层级遍历
    public static void levelTraverse(BitNode root) {
        Queue<BitNode> queue = new LinkedList<BitNode>();
        queue.offer(root);// 从根节点入队列
        while (!queue.isEmpty()) {// 在队列为空前反复迭代
            BitNode bitNode = queue.poll();// 取出队列首节点
            visitTNode(bitNode);
            if (bitNode.lchild != null)
                queue.offer(bitNode.lchild);// 左孩子入列
            if (bitNode.rchild != null)
                queue.offer(bitNode.rchild);// 右孩子入列
        }
    }

//测试
public static void main(String[] args) {
        BitNode root = new BitNode();
        int[] a = { 8,9,6,7,5,3,0};
root = createBiTree2(root, a, counter);
         System.out.println("-----递归先序遍历-----");
         PreOrderTraverse(root);
         System.out.println("\n-----非递归先序遍历-----");
         preorderTraverse(root);

         System.out.println("\n\n-----递归中序遍历-----");
         InOrderTraverse(root);
         System.out.println("\n-----非递归中序遍历-----");
         inorderTraverse(root);

         System.out.println("\n\n-----递归后序遍历-----");
         PostOrderTraverse(root);
         System.out.println("\n-----非递归后序遍历1-----");
         postorderTraverse(root);
         System.out.println("\n-----非递归后序遍历2-----");
         postorderTraverse2(root);

         System.out.println("\n\n-----层序遍历-----");
         levelTraverse(root);
}