数据结构 —— 二分搜索树

一、二分搜索的时间复杂度

二分搜索是一种高效的数据搜索，同时也可以高效的管理数据。高效就高效在它的结构，比如要找一个树中的数据，跟根一比，看大还是小，仔细想想，是真的很省时间，所以可以推断出它的时间复杂度一般在O(logn)（平衡）到O(n) （不平衡）之间，所以像Java底层源码使用的是红黑树，一种自平衡（AVL）的树，这样它的时间复杂度就是O(logn)了。

二、各种功能的实现

因为二分搜索一般是不包含重复元素的，所以要实现Comparable接口，（要用它的compareTo方法！）

public class BST<E extends Comparable<E>>

1、结点的定义，因为树是由结点构成的嘛

    private class Node{
        public E e;
        public Node left;
        public Node right;

        public Node(E e){
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST(){
        root = null;
        size = 0;
    }

    //增添,删除的时候要进行维护，即size ++; size--;
    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

2、添加结点的方法

    //向二分搜索树中添加新的结点
    public void add(E e){
        if(root == null) {
            root = new Node(e);
            size++;
        }
        //当根不为空的时候尝试从根节点开始插入新的元素
        else
            //注意这个add是private
            add(root, e);
    }

    //在上面方法的基础上，向以node为根的二分搜索树中插入元素E，（递归）
    private void add(Node node, E e){  //因为根是在不断变化的,node代表当前结点

        //递归终止条件
        if(e.equals(node.e)) //要插入的元素在二分搜索树中已经有了
            return;
        else if(e.compareTo(node.e) < 0 && node.left == null){
            node.left = new Node(e);    //把要加入的元素放进此空间
            size ++;
            return;
        }
        else if(e.compareTo(node.e) > 0 && node.right == null){
            node.right = new Node(e);   //左小<  右大>
            size ++;
            return;
        }

        //开始递归比较进行插入；
        //且要插入的元素就是在空的地方的
        if(e.compareTo(node.e) < 0)
            add(node.left, e);
        else
            add(node.right, e);
    }

我定义了一个公共的方法add和一个私有的方法add，后者是为前者服务的，前者是用来判断一切的开始 —— 根结点的，如果不存在那就在堆中new一个，如果存在那就好办了，直接进行私有递归方法的调用，为什么要再定义一个新的add()？因为如果要插入元素的话，基点肯定是当前的这个结点，但是还有元素e等着你添加啊，所以递归方法就有了两个参数，参数node代表当前结点，它是在不断变化的，e也是；所以这个私有add的意义就是向以node为根的二分搜索子树中插入元素e！剩余的就很简单，递归出口什么的都要有（见代码注释）。

3、查询结点的方法

    //看当前树中是否包含元素e
    public boolean contains(E e){
        return contains(root, e);
    }

    //在上面方法的基础上，向以node为根的二分搜索树中查询元素E，（私有，递归）
    private boolean contains(Node node, E e){

        if(node == null)
            return false;

        if(e.compareTo(node.e) == 0)
            return true;
        else if(e.compareTo(node.e) < 0)
            return contains(node.left, e);
        else if(e.compareTo(node.e) > 0)
            return contains(node.right, e);
        else{
            return false;
        }
    }

它跟add也很相似，但只是结构相似，也是一个公共的，一个私有的，同样，公共的是针对根的，相对add()比较简单。

4、前序遍历

    //非递归的前序遍历,(栈中的是结点，既然有结点那就是Node类)
    public void preOrderNR(){
        Stack<Node> stack = new Stack<Node>();
        stack.push(root);

        while(!stack.isEmpty()){
            //cur就是当前要访问的结点，弹出，并输出
            Node cur = stack.pop();
            System.out.println(cur.e);

            //在访问完cur结点后就去访问它对应的左右子树，并压入
            if(cur.left != null)
                stack.push(cur.left);
            if(cur.right != null)
                stack.push(cur.right);
        }
    }

递归的前中后都很简单，但是非递归的话只有前序来说比较简单，所以就用前序遍历了，非递归肯定是用栈做的，栈中的元素就是结点，还是先把root入栈再进行循环操作，在循环中要进行判空再去入栈。（见代码注解）

5、层序遍历

    //层序遍历(队列）
    public void levelOrder(){
        /**
         * 这种是错误的，因为Queue是个接口,不能直接被实例化
         * ：    Queue<Node> queue = new Queue<>();
         */
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            Node cur = queue.remove();
            System.out.println(cur.e);

            if(cur.left != null)
                queue.add(cur.left);
            if(cur.right != null)
                queue.add(cur.right);
        }
    }

层序遍历肯定用队列来做的，但是要注意Queue是个接口不能直接被实例化，所以只能先实例化它的子类。结构是类似上面的前序遍历的。cur是个结点，每次输出的是它的左(右)子树。

6、删除最小值并返回

    //删除二分搜索树的最小结点,并返回最小值
    public E removeMin(){
        E ret = minmum();  //提前保存返回这个最小的元素
        removeMin(root);
        return ret;
    }
    private Node removeMin(Node node){
        if(node.left == null){  //这个node就是要删的结点,node.left是它的左子树
            Node rightNode;  //rightNode用来保存当前结点的右子树（如果有的话）
            rightNode = node.right;
            node.right = null;
            size --;
            return rightNode;   //修改以及删除之后一定要返回新的！（这时最小节点就被删除啦）
        }

        //然后一直向左进行递归，因为最小值是一定在最左边的，且这个最小值没有左子树
        node.left = removeMin(node.left);
        return node;
    }

最小元素肯定是在最左边那个没有左子树的结点了，而里面的rightNode的作用就是如果这个结点它有右子树的话，那就把右子树先保存在rightNode,然后再去删除那个结点，最后接上那个右子树（即返回rightNode），任何修改和删除一般情况下是要返回新的值的。

7、删除任意结点

先写一个找最小结点的方法，因为删除结点要用到它

    //寻找二分搜索树的最小结点（最大结点同理）
    public E minmum(){
        if(size == 0)
            throw new IllegalArgumentException("empty");
        return minmum(root).e;
    }

    private Node minmum(Node node){
        if(node.left == null)
            return node;
        return minmum(node.left);
    }

删除方法：

    //删除任意一个元素
    public void remove(E e){
        root = remove(root, e);
    }

    //删除以node为根的二分搜索树中的 值为e的结点，（递归）
    //删除后就返回相对于当前根（不一定是根节点）来说新的根
    private Node remove(Node node, E e){
        if(node == null)
            return null;
        if(e.compareTo(node.e) < 0){
            node.left = remove(node.left, e); 
            return node;
        }
        else if(e.compareTo(node.e) > 0){
            node.right = remove(node.right, e); //继续深入
            return node;
        }


        else if(e.compareTo(node.e) == 0){   //定位到要删除的结点了
            //结点的左子树为空时
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }
            //结点的右子树为空时
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size --;
                return leftNode;
            }
            /**
             * 左右子树都不为空时
             * 先找到待删除结点右子树的最小结点，
             * 再用这个结点顶替待删除结点的位置（不需要做size--操作）
             */

            Node faitour = minmum(node.right);
            faitour.right = removeMin(node.right);
            faitour.left = node.left;
            node.left = node.right = null;
            return faitour;
        }
        else return null;
    }

首先先定位，一直递归找到要删除的元素，然后对他进行判断，有三种情况，有左无右，有右无左，有左有右，前两种在上面说过了，就是用rightNode(或者leftNode，得看是哪边)进行保存；麻烦的是既有左子树又有右子树，怎么改？有个科学家就想出来一个办法：左右子树都不为空时，先找到待删除结点右子树的最小结点，再用这个结点顶替待删除结点的位置。只需五行，见上图代码~ 上面说过的两个方法都要用，让这个结点继承删除这个结点后的右子树（说起来有点拗口）然后再让这个结点继承删除结点的左子树，再把删除结点的左右子树都置Null，这样它就永久被从树中去除了，最后不要忘，应返回删除后的结构（即返回这个faitour结点即可）。

三、运行结果

先贴上主函数：

package BST;

//关于树，首当其冲要做的操作的是跟root有关的，即根节点
//二分搜索树重要的是add()和contains()和remove()

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        BST<Integer> bst = new BST<Integer>();
        Random random = new Random();
        int n = 10;       //随机生成的元素个数
        for(int i=0; i < n; i++)
            bst.add(random.nextInt(10));

        System.out.println(bst.removeMin());
        System.out.println(bst.minmum());
        System.out.println(bst.contains(random.nextInt(10)));

        System.out.println("LevelOrder：");
        bst.levelOrder();
        System.out.println("PreOrder：");
        bst.preOrderNR();

        //再添加10个元素
        for(int i=0; i < n; i++)
            bst.add(random.nextInt(10));
        System.out.println("After Add Element PreOrder：");
        bst.preOrderNR();

        bst.remove(5);
        System.out.println("------");
        System.out.println(bst.size());
    }
}

运行后：

0
2
true
LevelOrder：
7
3
9
2
4
8
PreOrder：
7
9
8
3
4
2
After Add Element PreOrder：
7
9
8
3
4
6
5
2
0
1
------
9

确实没问题~

二叉搜索树确实是很快捷，我用上面这个代码把n设置为1000000，然后运行只需要1.5秒，也是很快的了。