散列表（离散链表法）

1.相关介绍

散列表也叫哈希表，英文名字Hash Table,有具体的哈希函数，将值映射到具体的表下标中。这样查找起来就十分方便。

散列表的注意点：

(1)散列函数要具有一致性，一个值通过散列表的映射得到的值是不变的，相同的值每次映射都是相同的结果。

(2)散列表中存的值，要均匀；如果值都聚集在一个位置，那么这个散列表就是糟糕的！

(3)填装因子应该小于0.7

填装因子=散列表中元素值个数/散列表中的总位置

当填装因子大于0.7时，需要进行调整！在满足装填因子的情况下，散列表中总位置尽量取素数，取上素数，发生冲突的概率小，但并不代表不发生！

哈希函数

目前我对哈希函数的理解，哈希函数本质上还是一个函数，就是你输入一个值，通过这个函数映射一个哈希表的索引下标；你把值存到哈希表中的话，你再次查找或者操作时，直接通过这个哈希函数，就可以立马找到！！！

方便快捷，哈哈！！

哈希函数1：输入参数1是字符串，参数2是散列表的大小

//将字符串中的字符的ASCII码相加
Index Hash1(char* Key,int TableSize)
{unsigned int HashVal=0;while(*Key!='\0'){HashVal+= *Key++; }return HashVal%TableSize;
}

哈希函数2

//u1s1，我不知道这是怎么想的
Index Hash2(char* Key,int TableSize)
{return (Key[0]+Key[1]*27+Key[2]*729)%TableSize;
}

哈希函数3

Index Hash3(char* Key,int TableSize)
{unsigned int HashVal=0;while(*Key!='\0'){HashVal=(HashVal<<5)+*Key++;    }return HashVal%TableSize;
}

2.散列表数据结构定义(关键)

#define MinTableSize (10)      //定义表的长度最小为10
typedef unsigned int Index;    //将unsigned int改名为Index
typedef int ElementType;       //将int改名为ElementType
struct ListNode{               //链表结构体定义，首先是数值，其次是指向下一个节点的指针ElementType Element;struct ListNode* Next;
};typedef  struct ListNode* Position;     //专门指链表的节点
typedef Position List;                  //专门指的是链表struct HashTbl{                         //哈希表的结构体定义int TableSize;                      //哈希表的尺寸List* TheLists;                     //相当于链表数组
};typedef struct HashTbl* HashTable;//这是正儿八经的哈希表

数据结构图示：

3.散列表的相关操作

1.辅助函数：寻找一个最接近N的素数（大于等于N）

bool IsPrime(int n);
//参数N，返回一个大于等于N的素数
int NextPrime(int N)
{while(!IsPrime(N)){N++;  }return N;
}//判断一个数是否是素数
bool IsPrime(int n)
{for(int i=2;i*i<n;i++){if(n%i==0){return false;    }   }return true;
}

这个函数还让我回忆了一波，如何判断一个数是否为素数！

简单说一下：（1）时间复杂度为O(N)的定义判断法（2）时间复杂度为O(N^1/2)的优化方法，如上代码所示！！

2.对于输入数值，最简单的哈希函数设定

//很简单的Hash函数
Index Hash(ElementType Key,int TableSize)
{return Key%TableSize;
}

3.初始化哈希表

这个的关键便是：要清楚哈希表的数据结构构造。

首先，哈希表结构体包含哈希表长度和链表数组。链表数组中的每一个都是一个链表。

HashTable InitTable(int TableSize)
{HashTable H=(struct HashTbl*)malloc(sizeof(struct HashTbl));//想给哈希表搞一个素数长度了H->TableSize=NextPrime(TableSize);//在你定的哈希表长度的基础上，找一个最接近的素数值//开辟一个链表数组H->TheLists=(List*)malloc(sizeof(struct ListNode)*H->TableSize);       //给链表数组挨个开辟头结点空间 for(int i=0;i<H->TableSize;i++){H->TheLists[i]=(List)malloc(sizeof(struct ListNode));H->TheLists[i]->Next=NULL;}   return H;
}

4.在哈希表中查找一个值的节点位置

//在哈希表中寻找一个值所在的节点位置
Position Find(ElementType X,HashTable &H)
{List L=H->TheLists[Hash(X,H->TableSize)];//先找到值所在的链表数组索引，然后找到对应的链表Position p=L->Next;while(p!=NULL){if(p->Element!=X){p=p->Next;    }   }return p;
}

思路so easy!先通过哈希表寻找链表数组，在链表数组的每个元素（链表）中，依次遍历每一个链表节点，寻找这个值！

5.将值插入到哈希表中

思路：先将该值放入设定好的Hash函数中，求出这个值对应在Hash表中的索引，然后在链表数组中找到这个链表，再在这个链表的表头进行插入，OK！

//将一个值插入到哈希表中
//思路其实没个啥，其实就是给一个值，通过哈希函数映射到对应的链表数组索引，然后在对应的链表中进行表头插入
void Insert(ElementType X,HashTable H)
{Position p=Find(X,H);//如果存在，就不用管了//如果不存在，就在对应的表头进行插入Position NewCell;if(p==NULL){List L=H->TheLists[Hash(X,H->TableSize)]; NewCell=(struct ListNode*)malloc(sizeof(struct ListNode));NewCell->Element=X;NewCell->Next=L->Next;L->Next=NewCell;}
}

6.销毁哈希表

思路：先依次销毁链表数组中的各个链表，然后销毁链表数组名，最后销毁哈希表！

//销毁表
void  DestroyTable(HashTable H)
{Position p;for(int i=0;i<H->TableSize;i++){p=H->TheLists[i];  //瞎想，沿着这条链子，只要能找到各个节点就能删除了 while(p!=NULL){Position term=p->Next;free(p);p=term;}}free(H->TheLists);free(H);
}