Java数据结构之——二叉树

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

（4）没有键值相等的节点。

三种遍历方式图示：

先序遍历：

中序遍历：

后序遍历：

代码实现：

//二叉排序树的实现
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;
    }
    
    /*
     * 将数据插入到排序二叉树中
     *
     **/
    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 = parent.left;
                    if(current == null){
                        parent.left = newNode;
                        return;
                    }
                }
                else{
                    current = parent.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 main(String[] args){
         BinaryTree biTree = new BinaryTree();
         int[] data = {2,6,5,8,9,4,7};
         biTree.buildTree(data);
         System.out.println("inOrder:");
         biTree.inOrder();
         System.out.println();
         System.out.println("preOrder:");
         biTree.preOrder();
         System.out.println();
         System.out.println("postOrder:");
         biTree.postOrder();
     }
}