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);
    }
}