【算法】第三章查找

##顺序查找 - 无序链表
太简单、直接上代码了

public Node(Key key,Value val,Node Next) {
	this.key = key;
	this.val = val;
	this.next = next;
}

public Value get(Key key) {
	for(Node n = first;n!=null;n=n.next) {
		if(n.key==key) {
			return n.val;
		}
	}
	return null;
}
	
public void put(Key key,Value val) {
	for(Node n = first;n!=null;n=n.next) {
		if(n.key==key) {
			n.val=val;
			return;
		}
	}
	
	first = new Node(key,val,first);
}

未命中 查找 N次 插入 N次
向空表插入N个数据 (N^2)/2 次比较

##二分法查找 -数组列表
也不是很难 直接代码

	//get
	public Value get(Key key) {
		int i = rank(key);
		if(i=i;j--) {
			keys[j] = keys[j-1];
			vals[j] = vals[j-1];
			if(j==i) {
				keys[i]=key;
				vals[i]=val;
			}
		}
		N++;
	}
	//core code rank
	public int rank(Key key) {
		int lo = 0;
		int hi = N - 1;
		int mid = lo + (hi - lo)/2;
		while(lo<=hi) {
			int cmp = key.compareTo(keys[mid]);
			if(cmp<0) 			hi = mid - 1;
			else if(cmp>0) 		lo = mid + 1;
			else				return mid;
			mid = lo + (hi - lo)/2;
		}
		return lo;
	}

在有N个键的有序数组中，二分查找最多需要 lgN+1 次比较
向有N个键的有序数组中，插入一个新元素最多需要 2N次比较

##二叉查找树
没有重点，直接代码

//二叉节点类 ， 注意每次更新要更新 节点数量N
	private class Node{
		private Key key;
		private Value val;
		private Node left, right;
		private int N;
		
		public Node(Key key,Value val,int N) {
			this.key = key;
			this.val = val;
			this.N = N;
		}
	}
	
	public Value get(Node x,Key key) {
		//if(key == root.key) return root.val;
		//else(key.compareTo(root.key))
		if(x == null) {return null;}
		int cmp = key.compareTo(x.key);
		//left right 常常写反，最后以后写得时候纸上比划一下
		if(cmp<0){
			 return get(x.right,key);
		}else if(cmp>0){
			return get(x.left,key);
		}else {
			return x.val;
		}
	}
	
	public Node put(Node x,Key key,Value val) {
		if(x == null) {
			return new Node(key,val,1);
		}
		int cmp = key.compareTo(x.key);
		if(cmp<0) x.left = put(x.right,key,val);
		else if(cmp>0) x.right = put(x.left,key,val);
		else x.val = val;
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}

和二分法相比 就是 插入和查找得效率差不多。
查找命中所需比较次数约为2lnN(1.39lgN)

求证：
设 Cn 为 n个元素得二叉查找树平均比较次数
则 平均查找成本为 （1 + Cn/n） //暂时不明白为什么 + 1

Cn = N - 1 + (C0 + Cn-1)/N + (C1 + Cn-2)/N + (C2 + Cn-3)/N + 。。。 + (Cn-1 + C0)/N
归纳得 Cn~ 2NlnN
//书上还有 最大 最小 向上取整 向下取整 太简单了 直接掠过。