算法-树（1）—BST（二叉搜索树）

本文基于BST结构主要实现查找，删除功能
此种数据结构较为简单，主要分析添加查找删除功能
后附完整代码

1.BST定义：
1).每个结点均有键值对，其中键值实现排序；
2).每个结点的都大于它的左结点，小于它的右结点。
2. 主要实现(递归)

结点内部类Node：`private class Node{    private Key key;    private Value value;    private Node left ,right;    private int N;    public Node(Key key,Value value,int N)    {        this.key = key;        this.value = value;        this.N = N;    }}`

1).添加put
思想：键值不能相同的原则，所以先递归查找是否存在这样的键值，若存在，则更新value值，否则添加相应的键值对到对应的位置。
实现：

    private Node put(Node x,Key key,Value value)    {        if(x == null)             return new Node(key,value,1);        int cmp = key.compareTo(x.key);        if (cmp<0)            x.left = put(x.left,key,value);        else if (cmp>0)            x.right = put(x.right,key,value);        else             x.value = value;        x.N = size(x.left)+size(x.right)+1;        return x;    }

2).删除deleteMin,delete
1.删除最小值：
查找最小值：递归查找左子树，若左子树为null，则递归右子树，查找Node.left==null的结点，次结点即为树的最小值。
删除最小值：删除最小值后，最小结点的右子树，接到最小值父结点的左子树中。

    private Node deleteMin(Node x)    {        if(x.left == null)            //此处返回需要删除的最小结点的右子树(这样才能保证后面结点不丢失).            return x.right;        //递归到最小结点时,返回了x.right,此处令最小结点的父结点的左子树等于返回的x.right.        //而需要删除的结点，被当成垃圾系统回收.        x.left = deleteMin(x.left);        //更新计数器.        x.N = size(x.left)+size(x.right)+1;            return x;    }

2.删除任意结点（传入键值）：
思想：首先肯定先递归查找的删除的键值（假设x结点），删除结点x时，我们需要使用到deleteMin，找到以x为父结点的子树的，用于替换x位置的结点。

    private Node delete(Node x,Key key)    {        if(x == null)            return null;        int cmp = key.compareTo(x.key);        if(cmp < 0)            x.left = delete(x.left,key);        else if(cmp > 0)            x.right = delete(x.right,key);        else        {            //此处x为需要删除的结点.判断x是否为单结点,若为单结点,返回x.left或者x.right即能删除x结点.            if(x.right == null)                return x.left;            if(x.left == null)                return x.right;            //若不为单结点.创建t结点，保存x的左右连接状态,再查找x右子树的最小结点(此结点即为新的取代x结点的结点).            Node tmp = x;            x = min(tmp.right);            x.right = deleteMin(tmp.right);            x.left = tmp.left;        }        x.N = size(x.left)+size(x.right)+1;        return x;    }

3.性能分析：
二分查找法（有序数组）：
最坏：查找—lgN。插入—N
平均：查找—lgN。插入—N/2
二叉查找树：
最坏：查找—N。插入—N
平均：查找—1.39lgN。插入—1.39lgN
BST的性能与树的高度成正比。
3. 完整代码

package search;/**  * @author : 罗正   * @date time：2016年9月7日 下午9:47:08 **/public class BSTsearch <Key extends Comparable<Key> ,Value>{    private Node root;    /**     * 内部类：树结点——Node     * @param args     */    private class Node    {        private Key key;        private Value value;        private Node left ,right;        private int N;        public Node(Key key,Value value,int N)        {            this.key = key;            this.value = value;            this.N = N;        }    }    public int size(){        return size(root);    }    private int size(Node x)    {        if (x == null)             return 0;        else             return x.N;    }    /**     * funtion:根据传入的key值，递归查找二叉树，无则返回null.     * @param key     * @return     */    public Value get (Key key)    {        return get(root,key);    }    private Value get(Node x,Key key)    {        if(x == null)            return null;        int cmp = key.compareTo(x.key);        if (cmp<0)            return get(x.left,key);        else if (cmp>0)            return get(x.right,key);        else            return x.value;    }    /**     * 查找key值，找到则更新，没有则添加.     * @param key     * @param value     */    public void put(Key key,Value value)    {        root = put(root,key,value);    }    /**     * 没有则插入root的子树当中     * @param x     * @param key     * @param value     * @return     */    private Node put(Node x,Key key,Value value)    {        if(x == null)             return new Node(key,value,1);        int cmp = key.compareTo(x.key);        if (cmp<0)            x.left = put(x.left,key,value);        else if (cmp>0)            x.right = put(x.right,key,value);        else             x.value = value;        x.N = size(x.left)+size(x.right)+1;        return x;    }    public Key min()    {        return min(root).key;    }    private Node min(Node x)    {        if(x.left == null)            return x;        return min(x.left);    }    /**     * 返回小于等于key的最大键.     * @param key     * @return     */    public Key floor(Key key)    {        Node x = floor(root,key);        if(x == null)            return null;        return x.key;    }    private Node floor(Node x,Key key)    {        if( x == null)            return x;        int cmp = key.compareTo(x.key);        if(cmp == 0)            return x;        if(cmp<0)            return floor(x.left,key);        Node t = floor(x.right,key);        if(t != null)            return t;        else            return x;    }    /**     * 根据传入的int k值，查找在树中的key值，并返回     * @param k     * @return     */    public Key select(int k)    {        return select(root,k).key;    }    private Node select(Node x,int k)    {        if(x == null)            return null;        int num = size(x.left);        if(num > k)            return select(x.left,k);        else if(num < k)            return select(x.right,k-num-1);        else             return x;    }    /**     * 根据传入的key，查找在树中的rank.     * @param key     * @return     */    public int rank(Key key)    {        return rank(root,key);    }    private int rank(Node x,Key key)    {        if( x == null)            return 0;        int cmp = key.compareTo(x.key);        if(cmp > 0)            //此处不要忘了加上1+size(x.left)            return 1+size(x.left)+rank(x.right,key);        if(cmp < 0)            return rank(x.left,key);        else            return size(x.left);    }    /**     * 以下为较难实现的BST删除操作.     * 实现步骤如下：     * 1.保存要删除的结点链接.（如删除A,保存t = B.left）.     * 2.A指向X = min(A.left).<这个结点就是删A后，取代A位置的结点！>     * 3.X取代A的操作,以及X位置抽取后,树变动的操作     *      * deletemMin().     * delete().     */    public void deleteMin()    {        root = deleteMin(root);    }    private Node deleteMin(Node x)    {        if(x.left == null)            return x.right;        x.left = deleteMin(x.left);        x.N = size(x.left)+size(x.right)+1;        return x;    }    /**     * 删除给定的键值对key.     * @param key     */    public void delete(Key key)    {        root = delete(root,key);    }    /**     * 递归删除key,     * 返回Node值,便于实现递归而不丢失链接.     * @param x     * @param key     * @return     */    private Node delete(Node x,Key key)    {        if(x == null)            return null;        int cmp = key.compareTo(x.key);        if(cmp < 0)            x.left = delete(x.left,key);        else if(cmp > 0)            x.right = delete(x.right,key);        else        {            //此处x为需要删除的结点.判断x是否为单结点,若为单结点,返回x.left或者x.right即能删除x结点.            if(x.right == null)                return x.left;            if(x.left == null)                return x.right;            //若不为单结点.创建t结点，保存x的左右连接状态,再查找x右子树的最小结点(此结点即为新的取代x结点的结点).            Node tmp = x;            x = min(tmp.right);            x.right = deleteMin(tmp.right);            x.left = tmp.left;        }        x.N = size(x.left)+size(x.right)+1;        return x;    }    public static void main(String[] args) {        // TODO Auto-generated method stub        BSTsearch bst = new BSTsearch<>();        bst.put("B", "b");        bst.put("A", "a");        bst.put("D", "d");        bst.put("W", "w");        bst.put("X", "x");        bst.put("Z", "z");        System.out.println(bst.select(0));        System.out.println("rank A:"+bst.rank("A"));        System.out.println("bst size :"+bst.size());        System.out.println("floor:"+bst.floor("Z"));        System.out.println("min :"+bst.min());        bst.deleteMin();        System.out.println("min (mid):"+bst.min());        bst.delete("B");        System.out.println("min :"+bst.min());        System.out.println("bst size:"+bst.size());    }}

算法第四版—二叉查找树