九种查找算法-哈希查找

哈希查找算法又称散列查找算法，是一种借助哈希表（散列表）查找目标元素的方法，查找效率最高时对应的时间复杂度为 O(1)。

哈希查找算法适用于大多数场景，既支持在有序序列中查找目标元素，也支持在无序序列中查找目标元素。讲解哈希查找算法之前，我们首先要搞清楚什么是哈希表。

哈希表是什么

哈希表（Hash table）又称散列表，是一种存储结构，通常用来存储多个元素。

和其它存储结构（线性表、树等）相比，哈希表查找目标元素的效率非常高。每个存储到哈希表中的元素，都配有一个唯一的标识（又称“索引”或者“键”），用户想查找哪个元素，凭借该元素对应的标识就可以直接找到它，无需遍历整个哈希表。

多数场景中，哈希表是在数组的基础上构建的，下图给大家展示了一个普通的数组：

哈希表：

我们使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素"分类"，然后将这个元素存储在相应"类"所对应的地方。但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了"冲突"，换句话说，就是把不同的元素分在了相同的"类"之中。后面我们将看到一种解决"冲突"的简便做法。

"直接定址"与"解决冲突"是哈希表的两大特点。

哈希函数：

规则：通过某种转换关系，使关键字适度的分散到指定大小的的顺序结构中，越分散，则以后查找的时间复杂度越小，空间复杂度越高。

算法思路：

如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键。

用给定的哈希函数构造哈希表；
根据选择的冲突处理方法(常见方法：拉链法和线性探测法)解决地址冲突；
在哈希表的基础上执行哈希查找；

代码：

#include<stdio.h>
#include<stdlib.h>#define SUCCESS 1
#define UNSUCCESS 0
#define OVERFLOW -1
#define OK 1
#define ERROR -1
#define MAXNUM 9999     // 用于初始化哈希表的记录 keytypedef int Status;
typedef int KeyType;// 哈希表中的记录类型
typedef struct
{KeyType key;
}RcdType;// 哈希表类型
typedef struct
{RcdType *rcd;int size;int count;int *tag;
}HashTable;// 哈希表每次重建增长后的大小
int hashsize[] = { 11, 31, 61, 127, 251, 503 };
int index = 0;// 初始哈希表
Status InitHashTable(HashTable &H, int size)
{int i;H.rcd = (RcdType *)malloc(sizeof(RcdType)*size);H.tag = (int *)malloc(sizeof(int)*size);if (NULL == H.rcd || NULL == H.tag) return OVERFLOW;KeyType maxNum = MAXNUM;for (i = 0; i < size; i++){H.tag[i] = 0;H.rcd[i].key = maxNum;}H.size = size;H.count = 0;return OK;
}// 哈希函数：除留余数法
int Hash(KeyType key, int m)
{return (3 * key) % m;
}// 处理哈希冲突：线性探测
void collision(int &p, int m)
{p = (p + 1) % m;
}// 在哈希表中查询
Status SearchHash(HashTable H, KeyType key, int &p, int &c)
{p = Hash(key, H.size);int h = p;c = 0;while ((1 == H.tag[p] && H.rcd[p].key != key) || -1 == H.tag[p]){collision(p, H.size);  c++;}if (1 == H.tag[p] && key == H.rcd[p].key) return SUCCESS;else return UNSUCCESS;
}//打印哈希表
void printHash(HashTable H)
{int  i;printf("key : ");for (i = 0; i < H.size; i++)printf("%3d ", H.rcd[i].key);printf("\n");printf("tag : ");for (i = 0; i < H.size; i++)printf("%3d ", H.tag[i]);printf("\n\n");
}// 函数声明：插入哈希表
Status InsertHash(HashTable &H, KeyType key);// 重建哈希表
Status recreateHash(HashTable &H)
{RcdType *orcd;int *otag, osize, i;orcd = H.rcd;otag = H.tag;osize = H.size;InitHashTable(H, hashsize[index++]);//把所有元素，按照新哈希函数放到新表中for (i = 0; i < osize; i++){if (1 == otag[i]){InsertHash(H, orcd[i].key);}}return OK;
}// 插入哈希表
Status InsertHash(HashTable &H, KeyType key)
{int p, c;if (UNSUCCESS == SearchHash(H, key, p, c)){ //没有相同keyif (c*1.0 / H.size < 0.5){ //冲突次数未达到上线//插入代码H.rcd[p].key = key;H.tag[p] = 1;H.count++;return SUCCESS;}else recreateHash(H); //重构哈希表}return UNSUCCESS;
}// 删除哈希表
Status DeleteHash(HashTable &H, KeyType key)
{int p, c;if (SUCCESS == SearchHash(H, key, p, c)){//删除代码H.tag[p] = -1;H.count--;return SUCCESS;}else return UNSUCCESS;
}int main()
{printf("-----哈希表-----\n");HashTable H;int i;int size = 11;KeyType array[8] = { 22, 41, 53, 46, 30, 13, 12, 67 };KeyType key;//初始化哈希表printf("初始化哈希表\n");if (SUCCESS == InitHashTable(H, hashsize[index++])) printf("初始化成功\n");//插入哈希表printf("插入哈希表\n");for (i = 0; i <= 7; i++){key = array[i];InsertHash(H, key);printHash(H);}//删除哈希表printf("删除哈希表中key为12的元素\n");int p, c;if (SUCCESS == DeleteHash(H, 12)){printf("删除成功，此时哈希表为：\n");printHash(H);}//查询哈希表printf("查询哈希表中key为67的元素\n");if (SUCCESS == SearchHash(H, 67, p, c)) printf("查询成功\n");//再次插入，测试哈希表的重建printf("再次插入，测试哈希表的重建：\n");KeyType array1[8] = { 27, 47, 57, 47, 37, 17, 93, 67 };for (i = 0; i <= 7; i++){key = array1[i];InsertHash(H, key);printHash(H);}getchar();return 0;
}