二分查找

二分查找

小弟初来咋到，面对算法一脸懵逼，希望各位大神能够给予指点，在此谢过。

基于有序数组的二分查找

思路：实现有序数组的Key有序需要在每次插入数据的时候找到该插入的位置，在升序数组中，可以先找中间值，如果比中间值大就在前半部分找，如果比中间值小就在后半部分找

import java.util.Arrays;

/**
 * 基于有序数组的二分查找
 * Created by Fearless on 2017/4/10.
 */
public class BinarySearchST <K extends Comparable<K> ,V> {
    private K[] keys;
    private V[] vals;
    private int length=0;
    public BinarySearchST(){
        keys= (K[]) new Comparable[4];
        vals= (V[]) new Object[4];
    }
    public BinarySearchST(int length){
        keys= (K[]) new Comparable[length];
        vals= (V[]) new Object[length];
    }

    /***
     * 扩容
     * @param max
     */
    private void resize(int max){
        K[] newKey= (K[]) new Comparable[max];
        V[] newVals= (V[]) new Object[max];
        System.arraycopy(keys,0,newKey,0,keys.length);
        System.arraycopy(vals,0,newVals,0,vals.length);
        keys=newKey;
        vals=newVals;
    }
    public boolean isEmpty(){
        return length==0;
    }
    public int size(){
        return length;
    }
    public V get(K key){
        if(isEmpty()) return null;
        int i=rank(key);
        //如果索引存在，返回该内容
        if(i<length&&keys[i].compareTo(key)==0) return vals[i];
        else return null;
    }
    /**
     *二分查找
     */
    private int rank(K key) {
        int fi=0;//查找的头索引
        int li=length-1;//查找的尾索引
        while (fi<=li){
            int min=fi+(li-fi)/2;//查找的中间索引
            int n=key.compareTo(keys[min]);//比较key值和中间值的大小
            //如果中间值比要查找的值大，就取查找前半部分
            //如果中间值比要查找的值小，就取查找后半部分
            if(n>0) fi=min+1;
            else if(n<0) li=min-1;
            else return min;
        }
        return fi;
    }

    /***
     * 插入数据
     * @param key
     * @param val
     */
    public void put(K key,V val){
        int i=rank(key);
        //如果在数组中间，且存在该键
        if(i<length&&keys[i].compareTo(key)==0){
            vals[i]=val;
            return;
        }
        //数据后移
        for(int j=length;j>i;j--){
            keys[j]=keys[j-1];
            vals[j]=vals[j-1];
        }
        //插入数据
        keys[i]=key;
        vals[i]=val;

        length++;
        //如果存储已满扩容
        if(length==keys.length) resize(length*2);
    }

    public K[] getKeys() {
        return keys;
    }

    public V[] getVals() {
        return vals;
    }
}
class BinarySearchSTDemo{
    private static String[] a={"A","F","M","D","H","J","L","E","C","K","I","B","G"};//测试数组
    public static void main(String ... args){
        BinarySearchST<String,Integer> bs=new BinarySearchST<>();
        for(int i=0;i<a.length;++i){
            bs.put(a[i],i);
        }
        System.out.println("keys:"+Arrays.toString(bs.getKeys()));
        System.out.println("values:"+Arrays.toString(bs.getVals()));
    }
}