##顺序查找 - 无序链表
太简单、直接上代码了
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<N&&keys[i].compareTo(key)==0) {return vals[i];}
else return null;
}
//put
public void put(Key key,Value val) {
if(val==null) {delete(key);return;}
int i = rank(key);
if(i<N&&keys[i].compareTo(key)==0) {vals[i]=val;return;}
for(int j = N;j>=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
//书上还有 最大 最小 向上取整 向下取整 太简单了 直接掠过。