基于无序链表和有序数组的查找

//基于无序链表的顺序查找
public class SequentialSearchST<key , Value>{
	private Node first;
	private class Node{
		Key key;
		Value val;
		Node next;
		public Node(Key key , Value val , Node next){
			this.key = key;
			this.val = val;
			this.next = next;
		}
	}
	public Value get(Key key){
		for (Node x = first ; x != null ; x = x.next){
			if(key.equals(x.key)) return x.val;
		}
		return null;
	}
	public void put(Key key , Value val){
		for (Node x = first ; x != null ; x = x.next){
			if(key.equals(x.key)){
				x.val=val;
				return;
			}
		}
		first = new Node(key ,val,first);
	}
}
//基于有序数组的二分查找
public class BinarySearchST<Key extends Comparable<key> , Value>{
	private Key[] keys;
	private Value[] vals;
	private int N;
	public BinarySearchST(int capacity){
		keys = (Key[]) new Comparable[capacity];
		vals = (Value[]) new Object[capacity];
	}
	public int size(){
		return N;
	}
	public Value get(Key key){
		if(isEmpty()) return null;
		int i = rank(key);
		if(i < N && keys[i].compareTo(key) == 0 ) return vals[i];
		else return null;
	}
	
	//迭代的二分查找
	public int rank(Key key){
		int lo = 0 , hi = N-1;
		while(lo <= hi){
			int mid = lo + (hi - lo)/2;
			int cmp = key.compareTo(keys[mid]);
			if(cmp < 0) hi = mid - 1;
			else if (cmp > 0) lo = mid + 1;
			else return mid;
		}
		return lo;
	}
	//递归的二分查找
	public int rank(Key key, int lo , int hi){
		if(hi < lo ) return lo;
		int mid = lo + (hi - lo)/2;
		int cmp = key.compareTo(keys[mid]);
		if(cmp < 0) rank(key ,lo ,mid -1);
		else if (cmp > 0) rank(key ,mid+1 ,hi);
		else return mid;
	}
}