基于二分查找与插入排序的符号表容器

基于二分查找与插入排序的符号表容器

符号表就是类似于编程常用的map，这里简单实现了一下

Api

   public ST()//构造器
   private void expansion()//扩容容器
   public Value get(Key key)//根据key获取value
   public boolean containKey(Key key)//二分查找符号表是否包含这个key
   public int keyIndex(Key key)//二分查找符号表里key的下标
   public void put(Key key,Value value)//向容器里添加一个key-value对
   private void insertSort(Key key,Value value)//添加key-value对并进行插入排序
   public void delete(Key key)//删除key-value对
   public int size()//返回符号表的真实大小
   private void swapKey(int i,int j)//交换俩个key的位置
   private void swapValue(int i,int j)//交换俩个value的位置
   private boolean less(Key a,Key b)//如果a<b，返回true
   private boolean isEquals(Key a,Key b)//如果a=b,返回true

实现

//基于二分查找与插入排序的符号表
//Key继承Comparable接口来保证良好的有序性
public class BinarySt<Key extends Comparable,Value> {
   private Key[] keys;      //键数组
   private Value[] values;  //值数组
   private int N = 0;       //键的数量
   private int realSize = 0;//符号表的真实大小
   //构造器，初始大小为2
   public BinarySt(){
       keys = (Key[]) new Comparable[2];
       values = (Value[]) new Object[2];
   }
   //扩容容器
   private void expansion(){
       Key[] newKeys = (Key[]) new Comparable[N*7/4];
       Value[] newValues = (Value[]) new Object[N*7/4];
       System.arraycopy(keys,0,newKeys,0,N);
       System.arraycopy(values,0,newValues,0,N);
       keys = newKeys;
       values = newValues;
   }
   //根据key获取value
   public Value get(Key key){
       int index;
       return -1==(index=keyIndex(key))?null:values[index];
   }
   //二分查找符号表是否包含这个key
   public boolean containKey(Key key){
       int begin = 0;
       int end = keys.length - 1;
       int mid;
       while (begin<=end){
           mid = (begin+end)/2;
           if (isEquals(key,keys[mid])){
               return null==values[mid]?false:true;
           }else if (less(key,keys[mid])){
               end = mid-1;
           }else {
               begin = mid+1;
           }
       }
       return false;
   }
   //二分查找符号表里key的下标
   public int keyIndex(Key key){
       int begin = 0;
       int end = N-1;
       int mid;

       while (begin<=end){
           mid = (begin+end)/2;
           if (isEquals(key,keys[mid])){
               return mid;
           }else if (less(key,keys[mid])){
               end = mid-1;
           }else {
               begin = mid+1;
           }
       }
       return -1;
   }
   //向容器里添加一个key-value对
   public void put(Key key,Value value){
       if (N == keys.length){
           expansion();
       }
       int index;
       if (-1 == (index = keyIndex(key))){
           realSize++;
           insertSort(key,value);
       }else {
           values[index] = value;
       }
   }
   //添加key-value对并进行插入排序
   private void insertSort(Key key,Value value){
       keys[N++] = key;
       values[N-1] = value;
       for (int i = N-1; i > 0; i--) {
           if (less(keys[i],keys[i-1])){
               swapKey(i,i-1);
               swapValue(i,i-1);
           }
       }
   }
   //删除key-value对
   public void delete(Key key){
       put(key,null);
       realSize--;
   }
   //返回符号表的真实大小
   public int size(){
       return realSize;
   }
   //交换俩个key的位置
   private void swapKey(int i,int j){
       Key temp = keys[i];
       keys[i] = keys[j];
       keys[j] = temp;
   }
   //交换俩个value的位置
   private void swapValue(int i,int j){
       Value temp = values[i];
       values[i] = values[j];
       values[j] = temp;
   }
   //如果a<b，返回true
   private boolean less(Key a,Key b){
       return a.compareTo(b) < 0;
   }
   //如果a=b,返回true
   private boolean isEquals(Key a,Key b){
       return a.compareTo(b)==0;
   }
}