散列表（哈希表）介绍

散列表的定义：

散列表是一种数据结构。理想的散列表数据结构是一个具有固定大小的数组。

散列函数：

对于数组的每一个对象，都会有一个关键字，我们成为键值，例如数据对象是一个字符串，就可以直接作为键值，如果数据对象是一个类，那可以取其中的某一个成员变量作为键值。将每个键值映射到从0到tableSize-1这个范围中的某个数，并且将其放到适当的单元中，这个映射就称为散列函数。理想情况下，它应该运算简单并且应该保证任何两个不同的键映射到不同的单元。

冲突：

理想的散列函数是不可能存在的，因为单元的数目是有限的，而键值实际上是用不完的。当两个键值散列到同一个单元的时候，这种情况称为冲突。解决冲突，也是散列表的重要的特征。

解决冲突的方法之分离链表法：

分离链表法，其做法是将散列到同一个值的所有元素保留到一个链表中。举个代码例子：

///***************************HashMap****************************/
//1.用数组形式建立哈希表
//2.使用链式方法解决冲突
//3.平方取中法通过字符串Hash函数求hash值（还有很多种其他的hash函数）
#include <iostream>
#include <string>
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

using namespace std;

typedef unsigned long(*GetKeyValue)(const string& );

//该类用来处理冲突的节点
template<class TypeA,class TypeB>
struct HashNode{
TypeA key;
TypeB value;
HashNode *next;
HashNode(TypeA key,TypeB value){
HashNode::key = key;
HashNode::value = value;
next = NULL;
}
HashNode& operator=(const HashNode& node){
key = node.key;
value = node.key;
next = node.next;
return *this;
}
};

//该类是HashMap用来存放hash表
template<class TypeA,class TypeB,class FuncType>
class HashMap
{
HashNode<TypeA,TypeB> **table;
unsigned long capacity;
FuncType GetKeyValue;
const TypeB TYPEB_NULL;
public:
HashMap(FuncType func,const TypeB& _null);
~HashMap();
TypeB Put(const HashNode<TypeA,TypeB>& hashNode);  //插入一个HashNode 返回该节点的value值
TypeB GetValue(const TypeA& key);  // 查找某个hashNode 其key为“key“的元素
TypeB Delete(const TypeA& key);  // 查找某个hashNode 其key为“key“的元素
};

template<class TypeA,class TypeB,class FuncType> //在调用的时候指定函数
HashMap<TypeA,TypeB,FuncType>::HashMap(FuncType func,const TypeB& _null) : TYPEB_NULL(_null)
{
capacity = 10000000;
GetKeyValue = func;
table = new HashNode<TypeA,TypeB>*[capacity];
for(unsigned i = 0;i < capacity;i++)
table[i] = NULL;
}

template<class TypeA,class TypeB,class FuncType>
HashMap<TypeA,TypeB,FuncType>::~HashMap(){
for(unsigned i = 0;i < capacity;i++){
HashNode<TypeA,TypeB> *currentNode = table[i];
while(currentNode)
{
HashNode<TypeA,TypeB> *temp = currentNode;
currentNode = currentNode->next;
delete temp;
}
}
delete table;
}

//新增节点操作，用鏈式法解決衝突
template<class TypeA,class TypeB,class FuncType>
TypeB HashMap<TypeA,TypeB,FuncType>::Put(const HashNode<TypeA,TypeB>& hashNode){
HashNode<TypeA,TypeB> *newNode = NULL;
unsigned long index = GetKeyValue(hashNode.key);
if(table[index] == NULL){
table[index] = new HashNode<TypeA,TypeB>(hashNode.key,hashNode.value);
newNode = table[index];
}
else{
newNode = table[index];
while(newNode->next){
newNode = newNode->next;
}
newNode->next = new HashNode<TypeA,TypeB>(hashNode.key,hashNode.value);
newNode = newNode->next;
}
return newNode->value;
}

//由键值获得value
template<class TypeA,class TypeB,class FuncType>
TypeB HashMap<TypeA,TypeB,FuncType>::GetValue(const TypeA& key){
unsigned long index = GetKeyValue(key);
if(table[index] == NULL)
return TYPEB_NULL;
else{
HashNode<TypeA,TypeB> *currentNode = table[index];
while(currentNode){
if(currentNode->key == key)
return currentNode->value;
currentNode = currentNode->next;
}
}
return TYPEB_NULL;
}

//由键值查找后，删除该节点，返回该删除的节点的value
template<class TypeA,class TypeB,class FuncType>
TypeB HashMap<TypeA,TypeB,FuncType>::Delete(const TypeA& key){
TypeB deletedNodeValue = TYPEB_NULL;
unsigned long index = GetKeyValue(key);
if(table[index] == NULL)
return deletedNodeValue;
else{
HashNode<TypeA,TypeB> *currentNode = table[index];
if(currentNode->key == key){
table[index] = currentNode->next;
deletedNodeValue = currentNode->value;
delete currentNode;
return deletedNodeValue;
}
while(currentNode){
if(currentNode->next->key == key){
HashNode<TypeA,TypeB> *temp = currentNode->next;
currentNode->next = currentNode->next->next;
deletedNodeValue = temp->value;
delete temp;
return deletedNodeValue;;
}
currentNode = currentNode->next;
}
}
return deletedNodeValue;
}

/***************************************测试****************************/
//平方取中法
//实现，取字符串中间3个字母，不足3个用0补足
unsigned long GetKeyValue_1(const string& key){
unsigned long keyValue = 0;
int strSize = key.size();
string tempStr(key);
for(int i = strSize;i < 3;i++)
tempStr = "0" + tempStr;
//如果大于3就取中间3位
if(strSize >= 3){
tempStr[0] = key[strSize / 2 - 1];
tempStr[1] = key[strSize / 2];
tempStr[2] = key[strSize / 2 + 1];
}
tempStr = tempStr.substr(0,3);
unsigned long num = 10000 * (unsigned long)(48);
num += 100 * (unsigned long)(tempStr[1]);
num += (unsigned long)(tempStr[2]);
num *= num;
char *numStr = new char[15];
snprintf(numStr,10,"%d",num) ;
int strLen = strlen(numStr);
tempStr = "000000";
for(int i = -2;i < 4;i++)
tempStr[2 + i] = numStr[strLen / 2 + i];
keyValue = strtol(tempStr.c_str(),NULL,10);

delete []numStr;
return keyValue;
}

int main()
{
clock_t start = clock();
//传入一个求哈希散列值的方法GetKeyValue_1
HashMap<string,string,GetKeyValue> hashMap(GetKeyValue_1,"NULL");
for(int i = 0;i < 100000;i++){
char *ckey = new char[20];
char *cvalue = new char[20];
snprintf(ckey,10,"%d",i);
snprintf(cvalue,10,"%d",i);
string key(ckey);
string value(cvalue);
if(i == 67){
key = "67";
value = "hello hash No.67";
}
HashNode<string,string> node1(key,value);
//插入该节点
hashMap.Put(node1);
//        cout << "index: " <<GetKeyValue_1(key) << " nodeValue: "
//             << hashMap.Put(node1) << endl;

}
clock_t end = clock();
cout << "Test Result: \n";
//调用了time.h文件的CLOCKS_PER_SEC，表示每过千分之一秒，clock()函数返回值加1
cout << "插入100000条数据耗时： "
<< double(end - start) / CLOCKS_PER_SEC << " 秒" << endl;
cout << "hashMap.GetValue(\"67\"): " << hashMap.GetValue("67") << endl;
cout << "hashMap.Delete(\"67\"): " << hashMap.Delete("67") << endl;
cout << "hashMap.GetValue(\"67\"): " << hashMap.GetValue("67") << endl;
return 0;
}

解决冲突方法之探测散列：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <windows.h>
#include <time.h>
#define MAXSIZE   20   //电话薄记录数量
#define MAX_SIZE 20     //人名的最大长度
#define HASHSIZE 53     //定义表长
#define SUCCESS 1
#define UNSUCCESS -1
#define LEN sizeof(HashTable)
typedef int Status;
typedef char NA[MAX_SIZE];

typedef struct{//记录
NA name;
NA tel;
NA add;
}Record;

typedef struct{//哈希表
Record *elem[HASHSIZE];     //数据元素存储基址
int count;                  //当前数据元素个数
int size;                   //当前容量
}HashTable;

Status eq(NA x,NA y)
{//关键字比较，相等返回SUCCESS；否则返回UNSUCCESS
if(strcmp(x,y)==0)
return SUCCESS;
else return UNSUCCESS;
}

Status NUM_BER;      //记录的个数

void getin(Record* a){//键盘输入各人的信息
printf("输入要添加的个数：\n");
scanf("%d",&NUM_BER);
int i;
for(i=0;i<NUM_BER;i++){

printf("请输入第%d个记录的用户名:\n",i+1);
scanf("%s",a[i].name);
printf("请输入%d个记录的电话号码:\n",i+1);
scanf("%s",a[i].tel);
printf("请输入第%d个记录的地址:\n",i+1);
scanf("%s",a[i].add);          //gets(str2);??????
}
}

void ShowInformation(Record* a)//显示输入的用户信息
{
int i;
for( i=0;i<NUM_BER;i++)
printf("\n第%d个用户信息:\n 姓     名：%s\n 电话号码：%s\n 联系地址：%s\n",i+1,a[i].name,a[i].tel,a[i].add);
}

void Cls(Record* a)
{
printf("*");
system("clear");
}

long fold(NA s)
{//人名的折叠处理
char *p;
long sum=0;
NA ss;
strcpy(ss,s);//复制字符串，不改变原字符串的大小写
// strupr(ss);//将字符串ss转换为大写形式
p=ss;
while(*p!='\0')
sum+=*p++;
printf("\nsum====================%d",sum);
return sum;
}

int Hash1(NA str)
{//哈希函数
long n;
int m;
n = fold(str);//先将用户名进行折叠处理
m = n%HASHSIZE;      //折叠处理后的数，用除留余数法构造哈希函数
return m;    //并返回模值
}

int Hash2(NA str)
{//哈希函数
long n;
int m;
n = atoi(str);//把字符串转换成整型数.
m = n % HASHSIZE;
return m;    //并返回模值
}

Status collision(int p,int c)
{//冲突处理函数，采用二次探测再散列法解决冲突
int i,q;
i=c/2+1;
while(i<HASHSIZE){
if(c%2==0){
c++;
q=(p+i*i)%HASHSIZE;
if(q>=0) return q;
else i=c/2+1;
}
else{
q=(p-i*i)%HASHSIZE;
c++;
if(q>=0) return q;
else i=c/2+1;
}
}
return UNSUCCESS;
}

void benGetTime();
void CreateHash1(HashTable* H,Record* a)
{//建表，以人的姓名为关键字，建立相应的散列表
//若哈希地址冲突，进行冲突处理
benGetTime();
int i,p=-1,c,pp;
for(i=0;i<NUM_BER;i++)
{
c=0;
p=Hash1(a[i].name);
pp=p;
while(H->elem[pp]!=NULL)
{
pp=collision(p,c);
if(pp<0)
{
printf("第%d记录无法解决冲突",i+1);//需要显示冲突次数时输出
continue;
}//无法解决冲突，跳入下一循环
}
H->elem[pp]=&(a[i]);   //求得哈希地址，将信息存入
H->count++;
printf("第%d个记录冲突次数为%d。\n",i+1,c);//需要显示冲突次数时输出
}
printf("\n建表完成!\n此哈希表容量为%d,当前表内存储的记录个数为%d.\n",HASHSIZE,H->count);
benGetTime();
}

void SearchHash1(HashTable* H,int c)
{//在通讯录里查找姓名关键字，若查找成功，显示信息
//c用来记录冲突次数,查找成功时显示冲突次数
benGetTime();
NA str;
printf("\n请输入要查找记录的姓名：\n");
scanf("%s",str);
int p,pp;
p=Hash1(str);
pp=p;
while((H->elem[pp]!=NULL)&&(eq(str,H->elem[pp]->name)==-1))
pp=collision(p,c);
if(H->elem[pp]!=NULL&&eq(str,H->elem[pp]->name)==1)
{
printf("\n查找成功！\n查找过程冲突次数为%d．以下是您需要要查找的信息：\n\n",c);
printf("姓   名：%s\n电话号码：%s\n联系地址：%s\n",H->elem[pp]->name,H->elem[pp]->tel,H->elem[pp]->add);
}
else printf("\n此人不存在，查找不成功!\n");
benGetTime();
}

void benGetTime()
{
// SYSTEMTIME sys; SHSIZE;      //用除留余数法构造哈希函数
// GetLocalTime( &sys );
time_t lt; /*define a longint time varible*/
lt=time(NULL);/*system time and date*/
printf(ctime(<)); /*english format output*/

// printf( "%4d/%02d/%02d %02d:%02d:%02d.%03d \n",sys.wYear,sys.wMonth,sys.wDay,sys.wHour,sys.wMinute, sys.wSecond,sys.wMilliseconds);
}

void CreateHash2(HashTable* H,Record* a)
{//建表，以电话号码为关键字，建立相应的散列表 若哈希地址冲突，进行冲突处理
benGetTime();
int i,p=-1,c,pp;
for(i=0;i<NUM_BER;i++)
{
c=0;
p=Hash2(a[i].tel);
pp=p;
while(H->elem[pp]!=NULL)
{
pp=collision(p,c);
if(pp<0)
{
printf("第%d记录无法解决冲突",i+1);//需要显示冲突次数时输出
continue;
}//无法解决冲突，跳入下一循环
}
H->elem[pp]=&(a[i]);   //求得哈希地址，将信息存入
H->count++;
printf("第%d个记录冲突次数为%d。\n",i+1,c);//需要显示冲突次数时输出
}
printf("\n建表完成!\n此哈希表容量为%d,当前表内存储的记录个数为%d.\n",HASHSIZE,H->count);
benGetTime();
}

void SearchHash2(HashTable* H,int c)
{//在通讯录里查找电话号码关键字，若查找成功，显示信息 c用来记录冲突次数,查找成功时显示冲突次数
benGetTime();
NA tele;
printf("\n请输入要查找记录的电话号码：\n");
scanf("%s",tele);
int p,pp;
p=Hash2(tele);
pp=p;
while((H->elem[pp]!=NULL)&&(eq(tele,H->elem[pp]->tel)==-1))
pp=collision(p,c);
if(H->elem[pp]!=NULL&&eq(tele,H->elem[pp]->tel)==1){
printf("\n查找成功！\n查找过程冲突次数为%d．以下是您需要要查找的信息：\n\n",c);
printf("姓   名：%s\n电话号码：%s\n联系地址：%s\n",H->elem[pp]->name,H->elem[pp]->tel,H->elem[pp]->add);
}
else printf("\n此人不存在，查找不成功!\n");
benGetTime();
}

void Save()
{
FILE *fp;
if((fp=fopen("c:\test.txt", "w"))==NULL){
printf("\nERROR opening customet file");
}
fclose(fp);
}

int main(int argc, char* argv[])
{
int c,flag=1;
HashTable *H;
H=(HashTable*)malloc(LEN);

int i=0;
for(;i<HASHSIZE;i++)
{
H->elem[i]=NULL;
H->size=HASHSIZE;
H->count=0;
}

Record a[MAXSIZE];
while (1)
{
printf("\n                       ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓                 ");
printf("\n                       ┃  欢迎使用电话号码查找系统 ┃                  ");
printf("\n        ┏〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓┓");
printf("\n        ┃ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ 哈希表的设计与实现 ★ ★ ★ ★ ★ ★ ★ ★ ★ ┃ ");
printf("\n        ┃            【1】.   添加用户信息                           ┃");
printf("\n        ┃            【2】.   读取所有用户信息                       ┃");
printf("\n        ┃            【3】.   以姓名建立哈希表(再哈希法解决冲突)     ┃");
printf("\n        ┃            【4】.   以电话号码建立哈希表(再哈希法解决冲突) ┃");
printf("\n        ┃            【5】.   查找并显示给定用户名的记录             ┃");
printf("\n        ┃            【6】.   查找并显示给定电话号码的记录           ┃");
printf("\n        ┃            【7】.   清屏                                   ┃");
printf("\n        ┃            【8】.   保存                                   ┃");
printf("\n        ┃            【9】.   退出程序                               ┃");
printf("\n        ┃   温馨提示：                                               ┃");
printf("\n        ┃            Ⅰ.进行5操作前 请先输出3                        ┃");
printf("\n        ┃            Ⅱ.进行6操作前 请先输出4                        ┃");
printf("\n        ┗〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓┛");
printf("\n");
printf("请输入一个任务选项>>>");
printf("\n");
int num;
scanf("%d",&num);
switch(num)
{
case 1:
getin(a);
break;
case 2:
ShowInformation(a);
break;
case 3:
CreateHash1(H,a);    /* 以姓名建立哈希表 */
break;
case 4:
CreateHash2(H,a);    /* 以电话号码建立哈希表 */
break;
case 5:
c=0;
SearchHash1(H,c);
break;
case 6:
c=0;
SearchHash2(H,c);
break;
case 7:
Cls(a);
break;
case 8:
Save();
break;
case 9:
return 0;
break;
default:
printf("你输错了，请重新输入!");
printf("\n");
break;
}
}

return 0;
}