java二叉排序树

　　二叉排序树又称二叉查找树。它或者是一颗空树，或者是具有如下性质的二叉树：

　　1.如果左子树不空，那么左子树上的所有节点均小于它的根节点的值；

　　2.如果右子树不空，那么右子树上的所有节点均大于它的根节点的值；

　　3.左右字树也分别是二叉排序树。

　　关于二叉排序树的建立和遍历的代码实现如下：

   class Node{
     public int data;
     public Node left;
     public Node right;
     public Node(int data){
         this.data = data;
         this.left = null;
         this.right = null;
     }
 }

 public class BinaryTree{

     private Node root;
     public BinaryTree(){
         root = null;
     }

     //将date插入到排序二叉树中
     public void insert(int data){
         Node newNode = new Node(data);
         if(root == null)
             root = newNode;
         else{
             Node current = root;
             Node parent;
             while (true) {    //寻找插入的位置
                 parent = current;
                 if(data < current.data){
                     current = current.left;
                     if(current == null){
                         parent.left = newNode;
                         return;
                     }
                 }
                 else{
                     current = current.right;
                     if(current == null){
                         parent.right = newNode;
                         return;
                     }
                 }
             }
         }
     }
     //输入数值，构建二叉树
     public void buildTree(int[] data){
         for (int i = 0; i<data.length; i++) {
             insert(data[i]);
         }
     }
     //中序遍历方法递归实现
     public void inOrder(Node localRoot){
         if (localRoot != null) {
             inOrder(localRoot.left);
             System.out.print(localRoot.data + " ");
             inOrder(localRoot.right);
         }
     }
     public void inOrder(){
         this.inOrder(this.root);
     }
     //先序遍历方法递归实现
     public void preOrder(Node localRoot){
         if (localRoot != null) {
             System.out.print(localRoot.data + " ");
             preOrder(localRoot.left);
             preOrder(localRoot.right);
         }
     }
     public void preOrder(){
         this.preOrder(this.root);
     }
     //后序遍历方法递归实现
     public void postOrder(Node localRoot){
         if (localRoot != null) {
             postOrder(localRoot.left);
             postOrder(localRoot.right);
             System.out.print(localRoot.data + " ");
         }
     }
     public void postOrder(){
         this.postOrder(this.root);
     }

     //层次遍历（利用一个队列实现）
     public static void levelOrder(Node localRoot){
         if(localRoot == null)
           return;
         List<Node> queue = new LinkedList<Node>();
         queue.add(localRoot);
         while(!queue.isEmpty()){
             Node temp = queue.poll(0);
             System.out.print(temp.data + " ");
             if(temp.left != null){
                 queue.add(temp.left);
             }
             if(temp.right != null){
                 queue.add(temp.right);
             }
         }
         System.out.println();
     }
     public void levelOrder(){
         this.levelOrder(this.root);
     }
 }