动态哈希表

动态哈希表的基本操作

 

函数实现部分

 

void InitHashBucket(HT* ht, int capacity)//初始化哈希表

{

if (ht == NULL)

{

return;

}

// 获取容量

capacity = GetPrime(capacity);

ht->table = (PNode*)malloc(sizeof(Node)*capacity);

//哈希表的初始化

for (int i = 0; i < ht->capacity; i++)

{

ht->table[i] = NULL;

}

//容量和元素个数

ht->size = 0;

ht->capacity = capacity;

}

 

 

int InsertHashBucketUnique(HT* ht, K key, V v)//插入不同的数据

{

if (NULL == ht)

{

return;

}

    ChechCapacity(ht);

//数据是否在表中

int num = HashFunc(ht, key);

PNode pcur = ht->table[num];

while (pcur)//不为空

{

if (pcur->_data._key == key)//已经存在，不需要再插入

{

return;//返回

}

pcur = pcur->_pNext;

 

}

//如果为空，则创建新节点

 

PNode pnewnode = BuyNode(key, v);//创建新节点

pnewnode->_pNext = ht->table[num];//将其插入

ht->size++;

}

 

int DeleteHashBucketUnique(HT* ht, K key)//删除不同的数

{

if (NULL == ht)

{

return;

}

int num = HashFunc(ht, key);

PNode pcur = ht->table[num];

PNode prev = NULL;

while (pcur)

{

if (pcur->_data._key == key)

{

prev->_pNext = pcur->_pNext;

free(pcur);

return 1;//找到了

}

prev = pcur;//记录prev

pcur = pcur->_pNext;

ht->size--;

}

return 0;

}

 

 

int DeleteHashBucketEqual(HT* ht, K key)//删除相同的数，2,22,2,2,32,4

{

if (NULL == ht)

{

return;

}

int num = HashFunc(ht, key);

PNode pcur = ht->table[num];

PNode prev = NULL;

while (pcur)

{

if (pcur->_data._key == key)

{

if (pcur == ht->table[num])//在头部，进行头删

{

ht->table[num] = pcur->_pNext;//将22放到头部

free(pcur);

pcur = ht->table[num];

//指向22

return 1;

}

prev = pcur;

prev->_pNext = pcur->_pNext;

}

prev = pcur;//记录prev

pcur = pcur->_pNext;

prev->_pNext = pcur->_pNext;

        ht->size--;

}

return 0;

}

PNode FindHashBucket(HT* ht, K key)//查找

{

if (NULL == ht)

{

return;

}

int num = HashFunc(ht, key);

PNode pcur = ht->table[num];

    while (pcur)

{

if (pcur->_data._key == key)

{

return pcur;

}

pcur = pcur->_pNext;//后移

return 0;

}

}

int ChechCapacity(HT* ht)//扩容

{

if (NULL == ht)

{

return;

}

//开辟新空间

if (ht->size == ht->capacity)

{

int i = 0;

unsigned long newcapacity = GetPrime(ht->capacity);

PNode *NewTable = (PNode*)malloc(sizeof(PNode)*newcapacity);

if (NULL == NewTable)

{

return 0;

}

//拷贝元素

for (i = 0; i < ht->capacity; i++)

{

if (ht->table)//先将旧哈希表中的数据取出来

{

PNode pcur = ht->table[i];

while (pcur)

{

int num = (int)pcur->_data._key%newcapacity;

ht->table[i] = pcur->_pNext;//取出旧表中的头

pcur->_pNext = NewTable[num];//指向新的表

NewTable[num] = pcur;//将值给过去

pcur = ht->table[i];//改变旧表中的头

}

 

}

}

//释放旧空间

ht->table = NewTable;

ht->capacity = newcapacity;//更新容量

free(ht->table);

return 1;

}

}

 

 

 

void DestroyHashBucket(HT* ht)//销毁哈希表

{

if (ht == NULL)

{

return;

}

for (int num = 0; num < ht->capacity; num++)

{

PNode pcur = ht->table[num];//删除每个桶中的元素

while (pcur)

{

ht->table[num] = pcur->_pNext;

free(pcur);

pcur = pcur->_pNext;

}

 

}

}

 

 

int HashFunc(HT* ht, K key)//哈希函数

{

PNode pcur = ht->table;

return (int)(pcur->_data._key) % (ht->capacity);

}

PNode BuyNode(K key, V value)//创建新节点

{

PNode pnewnode = (PNode*)malloc(sizeof(Node));//开辟空间

return pnewnode;

}

void PrintHashBucket(HT* ht)//打印哈希表

{

if (ht == NULL)

{

return;

}

for (int i = 0; i < ht->capacity; i++)

{

PNode pcur = ht->table[i];

while (pcur)

{

printf("d%,d%->", pcur->_data._key, pcur->_data._key);

 

}

printf("NULL\n");

}

}

unsigned long GetPrime( int data)//获取容量

{

for (int i = 0; i<_PrimeSize;i++)

 

{

if (_PrimeList[i]>data)

 

{

 

data = _PrimeList[i];

 

}

 

}

 

return data;

 

}

 

 

头文件

 

#include"stdio.h"

#include"assert.h"

#include"malloc.h"

 

typedef char* K;

typedef char* V;

 

typedef struct Pair

{

K _key;

V _value;

}Pair;

 

 

typedef (*phf)(int);

typedef struct Node

{

struct Node* _pNext;

Pair _data;

}Node, *PNode;

 

 

typedef struct HashTable

{

PNode* table;

unsigned long capacity;

unsigned long size;

}HT;

 

 

#define _PrimeSize  28      

 

static const unsigned long _PrimeList[_PrimeSize] =

 

{

 

53ul, 97ul, 193ul, 389ul, 769ul, 1543ul, 3079ul, 6151ul, 12289ul,

 

24593ul, 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, 1572869ul,

 

3145739ul, 6291469ul, 12582917ul, 25165843ul, 50331653ul, 100663319ul,

 

201326611ul, 402653189ul, 805306457ul, 1610612741ul, 3221225473ul, 4294967291ul

 

};

 

 

 

 

//////////////////////////////////////////////////////////

// .h

void InitHashBucket(HT* ht, int capacity);

int InsertHashBucketUnique(HT* ht, K key, V v);

int DeleteHashBucketUnique(HT* ht, K key);

 

void InsertHashBucketEqual(HT* ht, K key, V v);

int DeleteHashBucketEqual(HT* ht, K key);

PNode FindHashBucket(HT* ht, K key);

int ChechCapacity(HT* ht);

void DestroyHashBucket(HT* ht);

 

int HashFunc(HT* ht, K key);

PNode BuyNode(K key, V value);

void PrintHashBucket(HT* ht);

unsigned long GetPrime(int data);

 

 

 

 

 

测试函数

 

#include"HT.h"

 

int main()

{

HT ht;

int capacity = 0;

InitHashBucket(&ht,capacity);

InsertHashBucketUnique(&ht, 11,1);

InsertHashBucketUnique(&ht, 12,2);

InsertHashBucketUnique(&ht, 22, 2);

InsertHashBucketUnique(&ht, 67, 7);

 

PrintHashBucket(&ht);

DeleteHashBucketUnique(&ht,22);

    FindHashBucket(& ht, 67);

FindHashBucket(&ht, 78);

 

}