【模板】常用查找

参考：

http://blog.csdn.net/wzyhb123456789/article/details/6028735

一、基本概念：

1、  列表：待搜索的数据集合。

2、  关键字：要查找的那个数据。

3、  查找：一种算法过程。

二、基于线性表的查找：

1、  顺序查找：

(1)思想：逐个比较，直到找到或者查找失败。

(2)时间复杂度：T(n) = O(n)。

(3)空间复杂度：S(n) = O(n)。

(4)程序：

[cpp]  view plain  copy

1. Int SeqSearch(RecordList l, KeyType key)  
2. {  
3.          l.r[0].key = k;  
4.          I = l.length;  
5.          while(l.r[i].key != k)  
6.                    i--;  
7.          return  I;  
8. }  

2、  折半查找：

(1)思想：又称二分查找，对于已经按照一定顺序排列好的列表，每次都用关键字和中间的元素对比，然后判断是在前部分还是后部分还是就是中间的元素，然后继续用关键字和中间的元素对比。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

[cpp]  view plain  copy

1. Int BinSrch(RecordList l, KeyType k)  
2. {  
3.          low = 1;  
4.          high = l.length;  
5.          while(low <= high)  
6.          {  
7.               mid = (low + high) / 2;  
8.               if(k == l.r[mid].key)  
9.                    return mid;  
10.               else if(k < l.r[mid].key)  
11.                    high = mid -1;  
12.               else  
13.                    low = mid + 1;  
14.          }  
15.          return 0;  
16. }  

3、  分块查找：

(1)思想：把无序的列表分成若干子块（子表），然后建立一个索引表，记录每个子块中的某个关键字（最大的数或是最小的数），然后用关键字和这个索引表进行对比。该索引表还存储子块的起始位置，所以可以使用折半查找或者顺序查找确定关键字所在的子块位置。进入子块后，使用顺序查找查找。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：（略）

三、基于树的查找：

1、  二叉排序树：

(1)思想：二叉排序树：①若它的左子树非空，则左子树上所有节点的值均小于它的根节点的值；②若它的右子树非空，则右子树上所有结点的值均大于（或大于等于）它的根节点的值；③它的左、右子树也分别为二叉排序树。查找的时候，中序遍历二叉树，得到一个递增有序序列。查找思路类似于折半查找。

(2)时间复杂度：插入一个节点算法的O(㏒n)，插入n个的总复杂度为O(n㏒n)。

(3)空间复杂度：

(4)程序：

[cpp]  view plain  copy

1. BSTree SearchBST(BSTree bst, KeyType key)//递归算法  
2. {  
3.          If(!bst)  
4.                    return NULL;  
5.          else if(bst->key == key)  
6.                    return bst;  
7.          else if(bst->key > key)  
8.                    return SearchBST(bst->lchild, key);  
9.          else  
10.                    return SearchBST(bst->rchild, key);  
11. }  
12. BSTree SearchBST(BSTree bst, KeyType key)//非递归算法  
13. {  
14.          BSTree q;  
15.          q = bst;  
16.          while(q)  
17.          {  
18.                    If(q->key == key)  
19.                             return q;  
20.                    else if(q->key > key)  
21.                             q = q->lchild;  
22.                    else  
23.                             q = q->rchild;  
24.          }  
25.          return NULL;  
26. }  

2、  平衡二叉排序树：

(1)思想：首先它也是二叉排序树，但是还要具有如下性质：①左子树和右子树的深度之差的绝对值小于等于1；②左子树和右子树也是平衡二叉树。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

3、  B_树：

(1)思想：

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

四、计算式查找：

1、  哈希查找：

(1)思想：首先在元素的关键字k和元素的存储位置p之间建立一个对应关系H，使得p=H(k)，H称为哈希函数。创建哈希表时，把关键字为k的元素直接存入地址为H(k)的单元；以后当查找关键字为k的元素时，再利用哈希函数计算出该元素的存储位置p=H(k)，从而达到按关键字直接存取元素的目的。难点在于处理冲突的方式：①开放定址法②再哈希法③链地址法④建立公共溢出区。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

[cpp]  view plain  copy

1. #define m <哈希表长度>  
2. #define NULLKEY <代表空记录的关键字值>  
3.    
4. typedef int KeyType;  
5. typedef struct  
6. {  
7.          KeyType key;  
8. }RecordType;  
9.    
10. typedef RecordType HashTable[m];  
11.    
12. int HashSearch(HashTable ht, KeyType K)  
13. {  
14.          h0 = hash(K);  
15.          if(ht[h0].key == NULLKEY)  
16.                    return -1;  
17.          else if(ht[h0].key == K)  
18.                    return h0;  
19.          else  
20.          {  
21.                    for(i = 1; i <= m - 1; i++)  
22.                    {  
23.                             hi = (h0 + 1) % m;  
24.                             if(ht[hi].key == NULLKEY)  
25.                                      return -1;  
26.                             else if(ht[hi].key == K)  
27.                                      return hi;  
28.                    }  
29.                    return -1;  
30.          }  
31. }  

 

一、基本概念：

1、  列表：待搜索的数据集合。

2、  关键字：要查找的那个数据。

3、  查找：一种算法过程。

二、基于线性表的查找：

1、  顺序查找：

(1)思想：逐个比较，直到找到或者查找失败。

(2)时间复杂度：T(n) = O(n)。

(3)空间复杂度：S(n) = O(n)。

(4)程序：

[cpp]  view plain  copy

1. Int SeqSearch(RecordList l, KeyType key)  
2. {  
3.          l.r[0].key = k;  
4.          I = l.length;  
5.          while(l.r[i].key != k)  
6.                    i--;  
7.          return  I;  
8. }  

2、  折半查找：

(1)思想：又称二分查找，对于已经按照一定顺序排列好的列表，每次都用关键字和中间的元素对比，然后判断是在前部分还是后部分还是就是中间的元素，然后继续用关键字和中间的元素对比。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

[cpp]  view plain  copy

1. Int BinSrch(RecordList l, KeyType k)  
2. {  
3.          low = 1;  
4.          high = l.length;  
5.          while(low <= high)  
6.          {  
7.               mid = (low + high) / 2;  
8.               if(k == l.r[mid].key)  
9.                    return mid;  
10.               else if(k < l.r[mid].key)  
11.                    high = mid -1;  
12.               else  
13.                    low = mid + 1;  
14.          }  
15.          return 0;  
16. }  

3、  分块查找：

(1)思想：把无序的列表分成若干子块（子表），然后建立一个索引表，记录每个子块中的某个关键字（最大的数或是最小的数），然后用关键字和这个索引表进行对比。该索引表还存储子块的起始位置，所以可以使用折半查找或者顺序查找确定关键字所在的子块位置。进入子块后，使用顺序查找查找。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：（略）

三、基于树的查找：

1、  二叉排序树：

(1)思想：二叉排序树：①若它的左子树非空，则左子树上所有节点的值均小于它的根节点的值；②若它的右子树非空，则右子树上所有结点的值均大于（或大于等于）它的根节点的值；③它的左、右子树也分别为二叉排序树。查找的时候，中序遍历二叉树，得到一个递增有序序列。查找思路类似于折半查找。

(2)时间复杂度：插入一个节点算法的O(㏒n)，插入n个的总复杂度为O(n㏒n)。

(3)空间复杂度：

(4)程序：

[cpp]  view plain  copy

1. BSTree SearchBST(BSTree bst, KeyType key)//递归算法  
2. {  
3.          If(!bst)  
4.                    return NULL;  
5.          else if(bst->key == key)  
6.                    return bst;  
7.          else if(bst->key > key)  
8.                    return SearchBST(bst->lchild, key);  
9.          else  
10.                    return SearchBST(bst->rchild, key);  
11. }  
12. BSTree SearchBST(BSTree bst, KeyType key)//非递归算法  
13. {  
14.          BSTree q;  
15.          q = bst;  
16.          while(q)  
17.          {  
18.                    If(q->key == key)  
19.                             return q;  
20.                    else if(q->key > key)  
21.                             q = q->lchild;  
22.                    else  
23.                             q = q->rchild;  
24.          }  
25.          return NULL;  
26. }  

2、  平衡二叉排序树：

(1)思想：首先它也是二叉排序树，但是还要具有如下性质：①左子树和右子树的深度之差的绝对值小于等于1；②左子树和右子树也是平衡二叉树。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

3、  B_树：

(1)思想：

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

四、计算式查找：

1、  哈希查找：

(1)思想：首先在元素的关键字k和元素的存储位置p之间建立一个对应关系H，使得p=H(k)，H称为哈希函数。创建哈希表时，把关键字为k的元素直接存入地址为H(k)的单元；以后当查找关键字为k的元素时，再利用哈希函数计算出该元素的存储位置p=H(k)，从而达到按关键字直接存取元素的目的。难点在于处理冲突的方式：①开放定址法②再哈希法③链地址法④建立公共溢出区。

(2)时间复杂度：

(3)空间复杂度：

(4)程序：

[cpp]  view plain  copy

1. #define m <哈希表长度>  
2. #define NULLKEY <代表空记录的关键字值>  
3.    
4. typedef int KeyType;  
5. typedef struct  
6. {  
7.          KeyType key;  
8. }RecordType;  
9.    
10. typedef RecordType HashTable[m];  
11.    
12. int HashSearch(HashTable ht, KeyType K)  
13. {  
14.          h0 = hash(K);  
15.          if(ht[h0].key == NULLKEY)  
16.                    return -1;  
17.          else if(ht[h0].key == K)  
18.                    return h0;  
19.          else  
20.          {  
21.                    for(i = 1; i <= m - 1; i++)  
22.                    {  
23.                             hi = (h0 + 1) % m;  
24.                             if(ht[hi].key == NULLKEY)  
25.                                      return -1;  
26.                             else if(ht[hi].key == K)  
27.                                      return hi;  
28.                    }  
29.                    return -1;  
30.          }  
31. }