详细总结查找算法之顺序、二分、二叉搜索树、红黑树-原创手记-慕课网

前言

一般用符号表来储存键值对，就好像字典那样，通过索引来查找值，若键重复则覆盖值。我们能希望找到一种高效的查找算法使在平均情况和最差情况下，时间复杂度都能达到O(logn)。下面会逐步介绍四种算法，最终达到我们的目的。

顺序查找

用链表实现，无法索引数据，必须遍历找数据，速度比较慢，查找插入时间复杂度都为O(n)，而且无法保证有序。但是实现简单，适用于小型数据。

public class SequentialSearchST<Key,Value> {

private Node head;

private int size=0;

public void put(Key key,Value v){

Node p=head;

while(p!=null){

if(p.key.equals(key)){

p.v=v;

return;

}

p=p.next;

}

head=new Node(key,v,head);

size++;

}

public Value get(Key key){

Node p=head;

while (p!=null){

if(p.key.equals(key)){

return p.v;

}

p=p.next;

}

return null;

}

二分查找

用数组保存数据，保证有序。二分查找速度很快，但是仅限于查找。因为插入的时候要保证有序，所以要往后移动数据以便插入。查找复杂度O(logn),插入复杂度O(n)。

public class BinarySearch<Key extends Comparable,Value> {

public void put(Key key,Value value){

int index=rank(key);

//键相等则覆盖值

if(keys[index]!=null&&key.compareTo(keys[index])==0){

values[index]=value;

return;

}

//把数据往后移，以便插入

for(int i=size+1;i>index;i--){

keys[i]=keys[i-1];

values[i]=values[i-1];

}

keys[index]=key;

values[index]=value;

size++;

}

public Value get(Key key){

int index=rank(key);//二分查找

if(keys[index]!=null && key.compareTo(keys[index])==0){

return values[index];

}

return null;

}

public int rank(Key key){return rank(key,0,size);}

public int rank(Key key,int l,int h){

if(l>h) return l;

int mid = (l+h)/2;

int cmp=0;

if(keys[mid]!=null)

cmp=key.compareTo(keys[mid]);

if(cmp<0)

return rank(key,l,mid-1);

else if(cmp>0)

return rank(key,mid+1,h);

return mid;

}

二叉搜索树

通过前面两个算法，我们可以知道链表能快速删除插入，而二分能快速查找。所以我们想找到一种结构既是链式结构，同时又能进行二分查找，同时保证查找和插入的高效性。

答案就是二叉搜索树。

定义

是二叉树
每个节点含有一个键和关联的值
每个节点大于左子树上所有结点的值且小于右子树上所有节点的值

实现

其实给出定义，实现就已经很清楚了。说白了就是从无到有构造一个二叉树，每次插入都和树中的节点进行比较，小的放左边，大的放右边。就如同快速排序，用一个主元把左右两边分开。

还是直接看代码清楚点

public class BST<Key extends Comparable,Value>{

Node root;

public void put(Key key,Value value){

root = put(root,key,value);

}

public Node put(Node x, Key key, Value value) {

if(x==null){

return new Node(key,value,0);

}

int cmp = key.compareTo(x.key);

if(cmp<0) x.left=put(x.left,key,value);

else if(cmp>0) x.right=put(x.right,key,value);

else {

x.value=value;

x.N = size(x.right)+size(x.left)+1;

}

return x;

}

public Value get(Key key){

return get(root,key);

}

private Value get(Node x, Key key) {

if(x==null)

return null;

int cmp =key.compareTo(x.key);

if(cmp<0) return get(x.left,key);

else if(cmp>0) return get(x.right,key);

return x.value;

}

效率问题

二叉搜索树的查找和搜索在平均情况下时间复杂度都能达到O(logn)，而且能保证数据有序。二叉搜索树的中序遍历就是数据的顺序。我们貌似已经找到了一个最理想的算法。

但是这个效率只是在平均情况下。如果数据是逆序，或者顺序，那么这棵树就会发生一边倒的情况使复杂度直接达到O(n)，就如同快排中选择到糟糕的主元(最大或者最小)。比快排糟糕的是，快排我们能通过随机打乱数据来避免这种情况发生。但二叉搜索树则不行，数据都是客户提供，直接插入到树中的，这种情况其实经常发生。