算法_二叉查找树

　　二叉查找树支持将链表插入的灵活性和有序数组查找的高效性结合起来.数据结构由节点组成.节点包含的链接可以为null或者指向其他节点.在二叉树中,除了根节点以外,每个节点都有自己的父节点,且每个节点都只有左右两个链接,分别指向自己的左子节点和右子节点.因此可以将二叉查找树定义为一个空链接或者是一个有左右两个链接的节点,每个节点都指向一棵独立的子二叉树.

　　二叉查找树(BST)每个节点都包含有一个Comparable的键以及相关联的值,且每个节点的键都大于其左子树的任意节点的键而小于右子树的任意节点的键.

　　和链表一样,嵌套定义了一个私有类来表示二叉查找树上的节点,每个节点都含有一个键,一个值,一条左链接,一条右链接,和一个结点计数器(给出了以该节点为根的子树的节点总数).通过对于节点的递归操作实现了二叉树的基本插入,获取,删除操作,此外还支持和有序性相关的方法.代码如下:

import edu.princeton.cs.algs4.Queue;

public class BST<Key extends Comparable<Key>,Value> { 
    private Node root;        //二叉查找树的根节点.
    
    private class Node {
        private Key key;    //键
        private Value val;    //值
        private Node left,right;    //指向子树的链接
        private int N;                //以该结点为根的子树中的节点总数
        public Node(Key key, Value val,int N) {
            super();
            this.key = key;
            this.val = val;
            this.N=N;
        }
    }
    
    public int size() {
        return size(root);    //满足size(x)=size(x.left)+size(x.right)+1
    }
    
    private int size(Node x) {
        if(x==null) return 0;
        else return x.N;
    }
    
    public Value get(Key key) {
        return get(root,key);
    }
    
    private Value get(Node x, Key key) {
        //以x为根节点的子树中查找并返回key所对应的值.
        if(x==null) return null;
        int cmp=key.compareTo(x.key);        //与根节点的值作比较
        if(cmp<0) return get(x.left,key);    //如果小于根节点的值,那么在以x.left为根节点的子树寻找
        if(cmp>0) return get(x.right,key);    //如果大于根节点的值,那么在以x.right为根节点的子树寻找
        else return x.val;                    //返回根节点的值.
    }
    
    public void put(Key key,Value val) {
        //查找key,找到则更新它的值,否则为它创建一个新的节点.
        root=put(root,key,val);    
    }
    
    private Node put(Node x, Key key, Value val)/*x表示插入什么根节点*/ {
        //如果key存在于以x为根节点的子树中则更新它的值.否则以key和val为键值对的新节点插入到该自述中
        if(x==null) return new Node(key,val,1);
        int cmp=key.compareTo(x.key);
        if(cmp<0)    x.left=put(x.left,key,val);        //比根节点的键值小,则在左子树寻找,并更新左侧的根节点
        else if(cmp>0)    x.right=put(x.right,key,val);//比根节点的键值大,则在右子树寻找,并更新右侧的根节点
        else x.val=val;                        //与根节点相同,更新值
        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);            //如果有左节点,则在左节点中寻找最小的键值
    }
    public Key max() {
        return max(root).key;
    }
    public Node max(Node x) {
        return max(x.right);
    }

    //小于等于key的最大键 
    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 null;    //key是最小的键
        int cmp=key.compareTo(x.key);
        if(cmp==0)    return x;        
        if(cmp<0)    return floor(x.left,key);    //key位于根节点的左侧,因此小于等于key的键一定也位于左侧
        Node t=floor(x.right,key);    //key位于根节点的右侧.
        if(t!=null) return t;    //如果存在则返回存在的键值,不存在根节点就是小于等于key的最大键
        else return x;
    }
    //返回排名为k的节点
    public Key select(int k) {
        return select(root,k).key;
    }
    private Node select(Node x, int k) {
        if(x==null) return null;    //
        int t=size(x.left);        //左子树的总个数
        if(t>k)    return select(x.left,k);    //在左子树中寻找
        if(t<k)    return select(x.right,k-t-1);    //在右子树中寻找
        else return x;    //返回x
    }
    public int rank(Key key) {
        return rank(key,root);
    }
//返回以x为根节点的子树中小于x.key的键的数量.
    private int rank(Key key,Node x) {
        if(x==null) return 0;
        int cmp=key.compareTo(x.key);
        if(cmp<0) return rank(key,x.left);
        else if(cmp>0) return 1+size(x.left)+rank(key,x.right);
        else return size(x.left);
    }
//删除键值最小的子节点
    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;
    }
    public void delete(Key key) {
        root=delete(root,key);
    }

    public 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);
        if(cmp>0) x.right=delete(x.right,key);
        else {
            if(x.right==null) return x.left;
            if(x.left==null) return x.right;
            Node t=x;        //将要删除的节点赋值给t
            x=min(t.right);    //新节点为右子树中最小的节点
            x.right=deleteMin(t.right);    //将右子树更新
            x.left=t.left;    //左子树不变
        }
        x.N=size(x.left)+size(x.right)+1;
        return x;
    }
    //查找操作.
    public Iterable<Key> keys() {
        return keys(min(),max());
    }

    private Iterable<Key> keys(Key lo, Key hi) {
        Queue<Key> queue=new Queue<Key>();
        keys(root,queue,lo,hi);
        return queue;
    }

    private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
        if(x==null) return ;
        int cmplo=lo.compareTo(x.key);
        int cmphi=hi.compareTo(x.key);
        if(cmplo<0) keys(x.left,queue,lo,hi);    //查找根节点的左子树
        if(cmplo<=0&&cmphi>=0) queue.enqueue(x.key);    //查找根节点
        if(cmphi>0) keys(x.right,queue,lo,hi);    //查找根节点的右子树
    }
}

　　性能:对于二叉查找树而言:最坏情况下查找所需时间为N,插入所需时间为N,(时间与树的高度成正比),平均情况下,查找和插入所需时间为2InN,为了防止最坏情况的发生,即引出了平衡二叉查找树.对于二叉查找树,还有一种非递归的实现方法,效率更高,代码如下:

public class NonrecursiveBST<Key extends Comparable<Key>, Value> {

    private Node root;          

    private class Node {
        private Key key;                
        private Value value;            
        private Node left, right;       

        public Node(Key key, Value value) {
            this.key   = key;
            this.value = value;
        }
    }

    public void put(Key key, Value value) {
        Node z = new Node(key, value);
        if (root == null) { root = z; return; }
        Node parent = null, x = root;
        while (x != null) {
            parent = x;
            int res = key.compareTo(x.key);
            if      (res < 0) x = x.left;
            else if (res > 0) x = x.right;
            else { x.value = value; return; }  
        }
        int res = key.compareTo(parent.key);
        if (res < 0) parent.left  = z;
        else         parent.right = z;
    }
   

   
    Value get(Key key) {
        Node x = root;
        while (x != null) {
            int res = key.compareTo(x.key);
            if      (res < 0) x = x.left;
            else if (res > 0) x = x.right;
            else return x.value;
        }
        return null;
    }
    public Iterable<Key> keys() {
        Queue<Key> queue = new Queue<Key>();
        keys(root, queue);
        return queue;
    }
    private void keys(Node x, Queue<Key> queue) { 
        if (x == null) return; 
        keys(x.left, queue); 
        queue.enqueue(x.key); 
        keys(x.right, queue); 
    }