哈希（散列）：（四）C语言实现哈希开散列法

哈希（散列）的概念：

https://blog.csdn.net/mowen_mowen/article/details/82943192

C语言实现：静态哈希表：

https://blog.csdn.net/mowen_mowen/article/details/82943371

C语言实现：动态哈希表

https://blog.csdn.net/mowen_mowen/article/details/82943932

解决哈希冲突有两种方法：

一：闭散列：

也叫开放地址法；当发生哈希冲突时，如果哈希表未装满，则可以把数据存放到下一个空位置中去

要想达到一个好的闭散列减小哈希冲突的目的；就对我们的的哈希函数的选择提出了要求：

常见的哈希函数有：

直接定制法：

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关键字的分布情况适合查找比较小且连续的情况
除留余数法：

设散列表中允许的地址数为m，取一个不大于m，但接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key % p(p<=m),将关键码转换成哈希地址
平方取中法：

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
折叠法：

折叠法是将关键字从左到右分割成位数相等的几部分(后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
随机数法：

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数通常应用于关键字长度不等时采用此法

二：开散列法：

又叫链地址法（开链法）；将具有相同哈希地址的元素归于同一个子集，每一个子集合称一个桶，各个桶中的元素通过一个单链表链接起来，各个链表的头结点存储在哈希表中，

具体情形如图：

底层构造：

#pragma oncetypedef int DataType;typedef struct HashNode
{struct HashNode* _pNext;    //指向下一个节点DataType _data;
}HashNode;typedef struct HashBucket
{HashNode**_table;      //指向哈希表的首位置int _capacity;int _size;
}HashBucket;void HashBucketInit(HashBucket *ht,int capacity);
void HashBucketInsertUnique(HashBucket* ht,DataType data);  //只能插入不同元素
void HashBucketInsertEqual(HashBucket* ht,DataType data);   //可以插入相同元素
void HashBucketDelereUnique(HashBucket* ht,DataType data);  //相同元素只删除一个
void HashBucketDelereEqual(HashBucket* ht, DataType data);  //删除所有相同元素
int HashBucketSize(HashBucket *ht);
int HashBucketEmpty(HashBucket *ht);
void HashBucketDestroy(HashBucket *ht);
void PrintfHashBucket(HashBucket* ht);

具体操作：

#include<stdio.h>
#include<windows.h>
#include<assert.h>
#include<malloc.h>int HashFunc(HashBucket *ht,DataType data)           //获得哈希地址（除留余数法）
{return data % ht->_capacity;
}HashNode* BuyHashNode(DataType data)                //获得节点（插入时使用）
{HashNode* pNewNode = (HashNode*)malloc(sizeof(HashNode));if (NULL == pNewNode){assert(0);return NULL;}pNewNode->_data = data;pNewNode->_pNext = NULL;return pNewNode;
}void HashBucketInit(HashBucket *ht,int capacity)         //初始化
{int i = 0;assert(ht);ht->_table = (HashNode**)malloc(sizeof(HashNode) * capacity );if (NULL == ht->_table){assert(0);return;}for (; i <=capacity; i++)ht->_table[i]=NULL;ht->_capacity = capacity;ht->_size = 0;
}void HashBucketInsertUnique(HashBucket* ht, DataType data)
{HashNode * pNewNode = NULL;//计算元素的桶号int bucketNo = HashFunc(ht, data);    //检测元素是否在当前桶中HashNode* pCur = ht->_table[bucketNo];while (pCur){if (data == pCur->_data)return;pCur = pCur->_pNext;}//创建新节点pNewNode = BuyHashNode(data); //头插pNewNode->_pNext = ht->_table[bucketNo];ht->_table[bucketNo] = pNewNode;ht->_size++;
}void HashBucketInsertEqual(HashBucket* ht, DataType data)
{HashNode *pNewNode = NULL;//计算元素的桶号int bucketNo = HashFunc(ht, data);//创建新节点pNewNode = BuyHashNode(data);//头插pNewNode->_pNext = ht->_table[bucketNo];ht->_table[bucketNo] = pNewNode;ht->_size++;
}void HashBucketDelereUnique(HashBucket* ht, DataType data)
{HashNode * pPre = NULL;//计算元素的桶号int bucketNo = HashFunc(ht, data);//检测元素是否在当前桶中HashNode* pCur = ht->_table[bucketNo];while (pCur){if (data == pCur->_data){if (pCur == ht->_table[bucketNo])           //是首元素{ht->_table[bucketNo] = pCur->_pNext;}else                                        //不是首元素{ pPre->_pNext = pCur->_pNext;}free(pCur);ht->_size--;return;}pPre = pCur;pCur = pCur->_pNext;}
}
void HashBucketDelereEqual(HashBucket* ht, DataType data)
{HashNode * pPre = NULL;//计算元素的桶号int bucketNo = HashFunc(ht, data);//检测元素是否在当前桶中HashNode* pCur = ht->_table[bucketNo];while (pCur){if (data == pCur->_data){if (pCur == ht->_table[bucketNo])           //是首元素{ht->_table[bucketNo] = pCur->_pNext;free(pCur);pCur = ht->_table[bucketNo];ht->_size--;}else                                        //不是首元素{pPre->_pNext = pCur->_pNext;free(pCur);pCur = pPre->_pNext;ht->_size--;}}pPre = pCur;pCur = pCur->_pNext;}
}int HashBucketSize(HashBucket *ht)
{printf("有效元素个数为：%d\n", ht->_size);return ht->_size;
}int HashBucketEmpty(HashBucket *ht)
{return 0 == ht->_size;
}void HashBucketDestroy(HashBucket *ht)
{int i = 0;for (; i < ht->_capacity; i++){HashNode*pCur = ht->_table[i];while (pCur){ht->_table[i] = pCur->_pNext;free(pCur);pCur = ht->_table[i];} }free(ht->_table);ht->_capacity = 0;ht->_size = 0;
}void PrintfHashBucket(HashBucket* ht)
{int i = 0;for (; i < ht->_capacity; i++){HashNode*pCur = ht->_table[i];printf("第%d号桶:  ", i);while (pCur){printf("%d--->",pCur->_data);pCur =pCur->_pNext;}printf("NULL\n");}}

进行测试

新建源文件：Hash.c

#include"HashBucket.h"int main()
{HashBucket ht;                    //创建HashBucketInit(&ht, 10);           //初始化HashBucketInsertEqual(&ht, 2);      //插入HashBucketInsertEqual(&ht, 3);HashBucketInsertEqual(&ht, 5);HashBucketInsertEqual(&ht, 8);HashBucketInsertEqual(&ht, 12);HashBucketInsertEqual(&ht, 13);HashBucketInsertEqual(&ht, 15);HashBucketInsertEqual(&ht, 25);HashBucketInsertEqual(&ht, 18);HashBucketInsertEqual(&ht, 28);PrintfHashBucket(&ht);                //打印HashBucketSize(&ht);HashBucketDelereUnique(&ht, 15);       //删除HashBucketDelereUnique(&ht, 5);HashBucketDelereUnique(&ht, 28);PrintfHashBucket(&ht);HashBucketSize(&ht);HashBucketDestroy(&ht);                 //销毁system("pause");return 0;
}

运行结果

第0号桶:  NULL
第1号桶:  NULL
第2号桶:  12--->2--->NULL
第3号桶:  13--->3--->NULL
第4号桶:  NULL
第5号桶:  25--->15--->5--->NULL
第6号桶:  NULL
第7号桶:  NULL
第8号桶:  28--->18--->8--->NULL
第9号桶:  NULL
有效元素个数为：10第0号桶:  NULL
第1号桶:  NULL
第2号桶:  12--->2--->NULL
第3号桶:  13--->3--->NULL
第4号桶:  NULL
第5号桶:  25--->NULL
第6号桶:  NULL
第7号桶:  NULL
第8号桶:  18--->8--->NULL
第9号桶:  NULL
有效元素个数为：7请按任意键继续. . .