二叉查找树

/*

 *  二叉查找树(binary search/sort tree，BST)是具有如下性质的二叉树：对于二叉树中的任意一个结点，

 *  如果它包含的数据元素为data，那么它的左子树(如果非空)只包含小于data的元素，并且它的右子树

 *  (如果非空)只包含大于或者等于data的元素。它是一种动态树表，树结构在插入元素时生成。

 * 

 * */



public class BSTree {



    // 假设结点值为整数

    private static class BSTNode {

        private int value;

        private BSTNode left;

        private BSTNode right;



        public BSTNode() {

        }



        public BSTNode(int value) {

            this.value = value;

        }



        public int getvalue() {

            return value;

        }



        public void setvalue(int value) {

            this.value = value;

        }



        public BSTNode getLeft() {

            return left;

        }



        public void setLeft(BSTNode left) {

            this.left = left;

        }



        public BSTNode getRight() {

            return right;

        }



        public void setRight(BSTNode right) {

            this.right = right;

        }

    }



    private BSTNode root;

    private int size;



    // 构造空二叉树

    public BSTree() {

        clear();

    }



    // 构造只有一个节点的二叉树

    public BSTree(int value) {

        root = new BSTNode(value);

    }



    public final void clear() {    // 不可覆写

        root = null;

        this.size = 0;

    }



    /*

     *  node:二叉树上的一个节点

     *  value:要操作的数据

     *  

     *  */

    public BSTNode insert(BSTNode node, int value) {

        if (node == null) {

            size++;

            if (root == null) {        // 是否是空二叉树，根节点有些特殊，它没有父节点也是二叉树的起点

                root = new BSTNode(value);

                return root;

            }

            return new BSTNode(value);

        } else {

            if (value < node.value) {

                node.left = insert(node.left, value);

            } else {

                node.right = insert(node.right, value);

            }

        }

        return node;

    }



    // 直接插入二叉树，自动寻找到插入位置

    public void insert(int value) {

        insert(root, value);

    }



    private BSTNode search(BSTNode node, int value) {

        if(node == null) {

            return null;

        } else {

            if(value == node.value) {

                return node;

            } else if(value < node.value){

                return search(node.left, value);

            } else {

                return search(node.right, value);

            }

        }

    }

    

    public boolean contains(int value) {

        return (search(root, value) != null);

    }



    /*

     * 前序：根-左-右

     * 中序：左-根-右,将会得到从小到大排列的结点序列

     * 后序：左-右-根

     * 

     * */

    private void midList(BSTNode node) {

        if (node.left != null) {

            midList(node.left);

        }

        System.out.print(node.value + ",");

        if (node.right != null) {

            midList(node.right);

        }

    }



    public void midList() {

        midList(root);

    }

    

    // 逆中序(右-根-左)打印，打印后的结果顺时针旋转90°就是正常的二叉树形状了

    /*

     * @param  

     *         node: 打印的节点

     *         depth: 打印节点的深度

     * */

    private void print(BSTNode node, final int depth) {

        if(node == null) {

            return;

        }

        print(node.right,depth+1);        // 注意这里不能用depth++或++depth

        for(int i = 0; i < depth; i++) {

            System.out.print("    ");

        }

        System.out.println(node.value);

        print(node.left,depth+1);

    }

    

    // 打印二叉树

    public void print(){

        print(root,0);

    }

    

    public int size() {

        return size;

    }

}

public class BSTreeTest {



    /**

     * @param args

     */

    public static void main(String[] args) {

        BSTree bst = new BSTree();

        int[] array = new int[] {6,4,9,1,8,3,10};

        for(int i : array) {

            bst.insert(i);

        }

        System.out.println(bst.contains(1));

        bst.midList();

//        bst.print();

    }



}