java 实现二叉树的构建，先序，中序，后序，层次，递归，非递归的遍历

以下代码实现二叉树的构建，先序，中序，后序，层次，递归，非递归的遍历

package AlgorithmDesign;

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

public class TreeTraverse{

    int array[]=new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};   //数组用以存放构建二叉树的数据
    LinkedList<Node> nodelist=null;    //链表用以存放二叉树的结点

    class Node {     //内部类 定义节点
        Node left;
        Node right;
        int data;
        boolean flag;
        public Node(int Data){ //内部类构造函数
            left=null;
            right=null;
            data=Data;
            flag=false;
        }
    }

  //根据数组中的数创建二叉树
    public void creatTree(){
        nodelist=new LinkedList<Node>();
        // 将一个数组的值依次转换为Node节点
        for(int i=0;i<array.length;i++){
            nodelist.add(new Node(array[i]));
        }

         // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
        for(int ParentIndex=0;ParentIndex<array.length/2-1;ParentIndex++){
            // 左孩子 
            nodelist.get(ParentIndex).left=nodelist.get(2*ParentIndex+1);
            //右孩子 
            nodelist.get(ParentIndex).right=nodelist.get(2*ParentIndex+2);
        }
          // 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
        int lastParentIndex=array.length/2-1;
         // 只建立左孩子
        if(array.length%2==0){
            nodelist.get(lastParentIndex).left=nodelist.get(2*lastParentIndex+1);
        }
        // 右孩子,如果数组的长度为奇数才建立右孩子
        else if(array.length%2==1){
            nodelist.get(lastParentIndex).left=nodelist.get(2*lastParentIndex+1);
            nodelist.get(lastParentIndex).right=nodelist.get(2*lastParentIndex+2);
            }   
    }

   /*先序遍历   */ 
    public static void preOrderTraverse(Node node){//递归方式先序输出
        if(node!=null){
            System.out.print(node.data+", ");
            preOrderTraverse(node.left);
            preOrderTraverse(node.right);
        }else{
            return;
        }
    }

    /** 非递归实现先序遍历 */  
    protected static void PreOrderTraverse(Node p) {  
        Stack<Node> stack = new Stack<Node>();  
        while (p != null) {  
           if(p.right!=null){
               stack.push(p.right);
           }
           if(p.left!=null){
               stack.push(p.left);
           }
           System.out.print(p.data+", "); 
           if(!stack.empty()){
               p=stack.pop();
           }else{
               return;
           }
        }  
    }  

  //递归方式中序输出
    public static void inOrderTraverse(Node node){
        if(node!=null){
            inOrderTraverse(node.left);
            System.out.print(node.data+", ");
            inOrderTraverse(node.right);
        }else{
            return;
        }
    }

    /** 非递归实现中序遍历 */  
    protected static void InOrderTraverse(Node p) {  
        Stack<Node> stack = new Stack<Node>();  
        while (p != null) {  
            while (p != null) {  
                if (p.right != null)  
                    stack.push(p.right);// 当前节点右子入栈  
                stack.push(p);// 当前节点入栈  
                p = p.left;  
            }  
            p = stack.pop();  
            while (!stack.empty() && p.right== null) {  
                System.out.print(p.data+", ");  
                p = stack.pop();  
            }  
            System.out.print(p.data+", "); 
            if (!stack.empty())  
                p = stack.pop();  
            else  
                p = null;  
        }  
    }  

  //递归方式后序输出
    public static void postOrderTraverse(Node node){
        if(node!=null){
            postOrderTraverse(node.left);
            postOrderTraverse(node.right);
            System.out.print(node.data+", ");
        }else{
            return;
        }
    }

    /*
     * 非递归实现 后序遍历 
     * 需要设置一个标签，标志该结点是否被访问过
     * 如果该结点被访问过，则设置其flag值为true
     * */  
    protected static void PostOrderTraverse(Node p) {  
         Stack<Node> stack = new Stack<Node>();  
         while (!p.flag) {//如果节点p被访问过则设置其flag值为true
             while (!p.flag) {  
                 stack.push(p);// 当前节点入栈  
                 if (p.right != null && !p.right.flag)  
                     stack.push(p.right);// 当前节点右孩子入栈  
                 if (p.left != null && !p.left.flag){
                  p = p.left;  //沿左孩子一直到叶结点
                  }else{
                     break;
                 }
             }  
             p = stack.pop(); 
             while (!stack.empty() && (p.right== null||p.right.flag)&&(p.left== null||p.left.flag)) {  
             //当栈不空且左右孩子为空或已访问，访问当前结点
                 System.out.print(p.data+", ");  
                 p.flag=true;
                 p = stack.pop(); 
             }
             if  (stack.empty() && p!=null)  {//最后输出根结点
                 System.out.print(p.data+", ");  
                 p.flag=true; 
                 break; 
            }
            if  (stack.empty() && p==null)  {
                  break; 
             }
         }  
    }  

    public static void LevelTraverse(Node node){//二叉树的层次遍历
        Queue<Node> Q=new LinkedList<Node>(); //使用队列，先进先出
        while(node!=null){
            if(node.left!=null)  //如果左子树不空，则左子树入队
                Q.add(node.left);
            if(node.right!=null)  //如果右子树不空，则右子树入队
                Q.add(node.right);
            System.out.print(node.data+", ");
            node=Q.poll();
        }
        if(Q.isEmpty()){
            return;
        }
    }

 public static void main(String[] args) {
        TreeTraverse tree=new TreeTraverse();
        tree.creatTree();
        Node root=tree.nodelist.get(0);
        System.out.print("preOrder: ");
        preOrderTraverse(root);
        System.out.println();
        System.out.print("inOrder: ");
        inOrderTraverse(root);
        System.out.println();
        System.out.print("postOrder: ");
        postOrderTraverse(root);
        System.out.println();
        System.out.print("PreOrder: ");
        PreOrderTraverse(root);
        System.out.println();
        System.out.print("InOrder: ");
        InOrderTraverse(root);
        System.out.println();
        System.out.print("PostOrder: ");
        PostOrderTraverse(root);
        System.out.println();
        System.out.print("Level: ");
        LevelTraverse(root);

    }

}