有序符号表（数组实现，JAVA，算法(四)，二分法）

数组实现的有序符号表介绍：
两个平行数组，相同的下标分别是键和值，由于查入和删除需要调整数组大小，所以和无序链表一样，这两个操作仍然是线性的。但是符号表最为频繁的操作应该是查询的，查询操作可以使用二分法实现，达到了logN的复杂度。二分法的实现需要排好序的键，所以有了泛型的存在，需要实现Comparable接口。rank函数用二分法查找键，在很多函数里面我们都会使用这个函数以达到快速查找的能力。由于有序符号表的实现可以基于多种数据结构，但是它们的操作都是符号表常见操作，故在这里抽象出一个SymbolTable类，包装好以后的符号表使用的函数声明原型。

Comparable：为了使任意类型可比较，JAVA包装好的Integer，Double..这些类都实现了这个接口。当前类的函数接受一个Comparable类型的参数，只要实现了这个接口的类都可以作为参数传递，这就是接口回调，类似于上转型对象。

有序符号表基类：

package com.lizi.datastructure.symboltable;
//有序符号表基类
public abstract class SymbolTable<Key extends Comparable<Key>,Value> {

    //将键值对存入表中（若值为空则将建key从表中删除）
    public abstract void put(Key key,Value value);

    //获取键Key对应的值（若键key不存在返回空）
    public abstract Value get(Key key);

    //从表中删去键key（及其对应的值）
    public abstract Value delete(Key key);

    //表中是否存在该键
    public boolean contains(Key key){
        return get(key)!=null;
    }

    //表是否为空
    public boolean isEmpty(){
        return size()==0;
    }

    //表中的键值对数量
    public abstract int size();

    //最小的键
    public abstract Key min();

    //最大的键
    public abstract Key max();

    //小于等于Key的最大键
    public abstract Key floor(Key key);

    //大于等于Key的最小键
    public abstract Key ceiling(Key key);

    //小于key的键的数量
    public abstract int rank(Key key);

    //删除最小的键
    public void deleteMin(){
        delete(min());
    }

    //删除最大的键
    public void deleteMax(){
        delete(max());
    }
    //返回下标为index的键
    public abstract Key select(int index);
    //[low....high]之间键的数量,包括相等元素
    public int size(Key low,Key high){
        if (high.compareTo(low)<0)
            return 0;
        else if (contains(high))
            return rank(high)-rank(low)+1;
        else 
            return rank(high)-rank(low);
    }

    //[low....high]之间键的集合，已经排序
    public abstract Iterable<Key> keys(Key low,Key high);

    //表中所有键的集合，已经排序
    public Iterable<Key> keys(){
        return keys(min(),max());
    }

}

以下是数组实现的符号表：

package com.lizi.datastructure.symboltable;

import java.util.ArrayList;
import java.util.List;
//二分搜索，基于排序数组
public class BinarySearchST<Key extends Comparable<Key>,Value> extends SymbolTable<Key, Value> {

    private Key[] keys;
    private Value[] values;
    private int size=0;
    @SuppressWarnings("unchecked")
    public BinarySearchST(int capacity) {
        keys=(Key[]) new Comparable[capacity];
        values=(Value[]) new Object[capacity];//java不允许泛型数组，只能创建Object再强制转换类型
        this.size=0;
    }
    @Override
    public void put(Key key, Value value) {
        if(value==null) {delete(key); return;}
        //如果键存在，则修改键值
        int pos=rank(key);
        if (pos<size&&keys[pos].compareTo(key)==0) {
            values[pos]=value;
            return;
        }
        //键值不存在，判断数组是否越界并将数组扩容
        if(size==keys.length) resize(2*keys.length);
        for (int i =size; i>pos; i--) {
            keys[i]=keys[i-1];
            values[i]=values[i-1];
        }
        keys[pos]=key;
        values[pos]=value;
        size++; 
    }

    @Override
    public Value get(Key key) {
        if(isEmpty()) return null;
        int pos=rank(key);
        if (pos<size&&keys[pos].compareTo(key)==0) 
            return values[pos];
        else return null;
    }

    @Override
    public Value delete(Key key) {
        int pos=rank(key);
        //没找到则返回空
        if (pos<size&&keys[pos].compareTo(key)!=0) {
            return null;
        }
        Value value = values[pos];
        if(size<keys.length/2) resize(keys.length/2);
        for (int i = pos; i < size - 1; i++) {
            keys[i] = keys[i + 1];
            values[i] = values[i + 1];
        }
        size--;
        return value;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Key min() {
        return keys[0];
    }

    @Override
    public Key max() {
        return keys[size-1];
    }

    @Override
    public Key floor(Key key) {
        int pos=rank(key);
        if (pos<size&&keys[pos].compareTo(key)==0) {
            return keys[pos];
        }
        return keys[pos-1];
    }

    @Override
    public Key ceiling(Key key) {
        int pos=rank(key);
        return keys[pos];
    }
    //非递归的二分查找
    @Override
    public int rank(Key key) {
        int low=0;
        int high=size-1;
        while (low<=high) {
            int middle=low+(high-low)/2;
            int cmp=key.compareTo(keys[middle]);
            if (cmp<0) high=middle-1;
            else if(cmp>0) low=middle+1;
            else return middle;
        }
        return low;
    }
    //递归的二分查找
    public int rank(Key key,int low,int high) {
        if(low>high) return low;
        int pos=rank(key);
        int cmp=key.compareTo(keys[pos]);
        if (cmp>0) return rank(key, pos+1, high);
        else if(cmp<0) return rank(key,low,pos-1);
        else return pos;
    }
    @Override
    public Key select(int index) {
        return keys[index];
    }
    @Override
    public Iterable<Key> keys(Key low, Key high) {
        List<Key> keys=new ArrayList<Key>(size);
        for (int i = 0; i <size; i++) {
            keys.add(this.keys[i]);
        }
        return keys;
    }
    //该函数仅仅将容量扩大，但是有效元素数量并未改变，所以大小还是size
    @SuppressWarnings("unchecked")
    public void resize(int capacity) {
        Key[] newKeys=(Key[]) new Comparable[capacity];
        Value[] newValues=(Value[]) new Object[capacity];
        for (int i = 0; i < size; i++) {
            newKeys[i]=keys[i];
            newValues[i]=values[i];
        }
        keys=newKeys;
        values=newValues;
    }
}