二叉树的先序、中序、后序的递归及非递归实现，以及层次遍历的实现：

先序遍历的实现：

先序递归实现方式：

[code]public static void preOrderTraver(TreeNode root){
        if(root!=null){
            System.out.print(root.value+" ");
            preOrderTraver(root.left);
            preOrderTraver(root.right);
        }      
    }

先序非递归实现方式（使用栈）：先序遍历入栈前，先访问根节点；然后将指向左节点，一路访问，然后入栈；直到左节点为空的时候，弹出栈顶节点，指向右节点，重复上面的操作。

[code]public static void preOrderTraver(TreeNode root){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        while(p!=null||!stack.isEmpty()){
            if(p!=null){
                System.out.print(p.value);
                stack.push(p);
                p = p.left;
            }
            else{
                p = stack.pop();
                p=p.right;
            }
        }
    }

中序遍历的实现：

中序递归实现方式：

[code]public static void inOrderTraver(TreeNode root){
        if(root!=null){
            inOrderTraver(root.left);
            System.out.print(root.value+" ");
            inOrderTraver(root.right);
        }
    }

中序非递归实现方式（使用栈）：和先序类似，从根节点开始，将左子树一路入栈；直到左节点为空的时候，弹出栈顶节点，顺便访问该节点，然后指向右节点，重复上面的操作

[code]public static void inOrderTraver(TreeNode root){
        Stack<TreeNode>stack = new Stack<TreeNode>();
        TreeNode p = root;
        while(p!=null || !stack.isEmpty()){
            if(p!=null){
                stack.push(p);
                p = p.left;
            }
            else{
                p = stack.pop();
                System.out.print(p.value+" ");
                p = p.right;
            }
        }
    }

后序遍历的实现：

后序递归实现方式：

[code]public static void inOrderTraver(TreeNode root){
        if(root!=null){
            inOrderTraver(root.left);
            inOrderTraver(root.right);
            System.out.print(root.value+" ");
        }
    }

后序非递归实现方式（使用栈）：取栈顶元素，查看当前节点，如果其符合访问条件，则访问该节点，弹出；反之按照先右节点，后左节点的顺序入栈。依次循环，直到所有的节点都被访问到为止。

[code]public static void postOrderTraver(TreeNode root){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        //p是最后一个访问到的节点
        TreeNode last = root;
        while(!stack.isEmpty()){
            p = stack.peek();
            if((p.left==null && p.right==null)||(p.right==last)||(p.left==last&&p.right==null)){
                System.out.println(p.value);
                last = p;
                stack.pop();               
            }
            else{
                if(p.right!=null){
                    stack.push(p.right);
                }
                if(p.left!=null){
                    stack.push(p.left);
                }              
            }
        }
    }

层次遍历的实现（使用队列）：首先将根节点加入到队列中，然后弹出根节点，并且访问根节点，然后判断根节点的左右子树是否为空，添加左右节点入队列。

[code]public static void levelTraver(TreeNode root){
        Queue<TreeNode>queue = new LinkedList<TreeNode>();      
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode p = queue.poll();
            System.out.println(p.value+" ");
            if(p.left!=null){
                queue.add(p.left);
            }
            if(p.right!=null){
                queue.add(p.right);
            }
        }      
    }