数据结构算法-哈希表技术点

引言

小森是一名 “ikun科技大制作创作者” 但有自己的团队 团队有20个人, 4个人为一组 ,一共有五组
分别为 策划组, 制作组, 配音组 ,编剧组, 调音组
为了方便就为每一个组的人就起了编号 以后方便"考察每个人是否工作"

可以看到效率大大的提高工作效率 ,当然真ikun 是真的为爱发电做出来:第一个 “科你太美PV”" 来致敬科比,
当然由于科技含量,最大化 最终真正出来"科技小森寻找科比"这个"游戏"
接下来 “科技小森寻找科比” 可能还得扩展到"鹰酱",并且在文化和科技反复碾压",让他们非常服
突然"科技小森工作室"宣布和"米啊游"合并 并且打造 “ikun文化” 让"ikun 文化名扬万朽"
在这不愧是"我森哥的格局最大"

从这里让人明白了一个关键点: 分散的重要性 就是非常好查找数据

肯定某个组有人因为薪资问题离开,这就恰到好处,无论是哪个组哪个人都会有编号
比如说"配音组里的1002 因为薪资问题.未能得到解决",那只好辞退Ta 并且赔偿一些费用
非常快速把ta从数字存储引擎把Ta的个人档案销毁

以下这种情景,我想一定能撬开阁下的嘴(,哈哈哈,笑不活了)

好了 该到打退骚针的时候 那么 这算不算是本文章的主题?

当然算,不然我怎么可能会说出来呢 (注意看 这个作者 有点骚 需打一针 ,退骚针就好了)

哈希表原理

哈希表也称之为散列表

顺序表和链表的结合体 重温 一下 顺序表 的优点 :可控范围随机访问 链表的优点 :插入非常快 删除非常快
所以说链表和顺序表是互补的,
将二者合二为一 就变成 哈希表
可以看到,这就是一个指针数组 维护一大堆的链表
你需要知道的是: 数据如何插入和删除
难道顺着插入?
要是这样的话 还不如用链表

所以引用 “哈希函数”
“哈希函数”: 将数据转化为数字 映射到哈希表里的一种函数 也就是说 将数据转化为序号,最后插入到哈希表
哈希函数 可以多种多样 最多用的是取余
这对于通用的数据来采取的方式

哈希桶:存放链表的数组 或者 顺序表的数组

数据：采用键值（key/value）对的方式，键是哈希桶的编号 值是对应的数据，
这种非常神奇神奇到忽略不计去 哈哈
这种方式可能非常快速的找到对应的数据
通过上面的引言都知道 组就是键，数据是员工编号

我们的指纹识别就是用了这样的哈希表原理
音乐的听歌识曲也用了底层算法，所以现在知道为啥第一次办理身份证的时候就录入指纹 只要你一旦犯罪 人民警察会通过指纹快速查找到犯罪嫌疑人

哈希表算法实现

哈希链表定义

• 数据的定义

 using Key = int;
 using Value = use define;

//哈希数据
struct HashValue{
	Key key;
	Value value;
};

struct LinkNode{
   
   HashValue MyHashValue;
   LinkNode*Next; 
};
//哈希表元素类型
using HashElement=LinkNode*;

哈希表定义

//默认桶空间容量
const int default_BucketSpaceSize = 16;
 
//哈希桶
using HashBucket = HashElement*;

//哈希表
struct HashTable{
   HashBucket BucketSpace;//桶空间
   size_t BucketSpaceSize;//桶空间大小
};

哈希链表创建算法

bool CreateHashTable(HashTable& HashTable, int BucketSpaceSize) {

	BucketSpaceSize = BucketSpaceSize <= 0 ? default_BucketSpaceSize : (BucketSpaceSize > default_BucketSpaceSize ? BucketSpaceSize : default_BucketSpaceSize);

	HashBucket BucketSpace = HashTable.BucketSpace = (HashElement*)malloc(sizeof(HashBucket) * (HashTable.BucketSpaceSize = BucketSpaceSize));


	if (BucketSpace) {

		for (size_t i = 0; i < BucketSpaceSize; i++) {

			BucketSpace[i] = (HashElement)malloc(sizeof(HashElement));
			*BucketSpace[i] = { };
		}

		return true;
	}

	return  false;

}

哈希链表插入算法

首先 我们需要数据 那么得需要创建 按照我以前的骚操作文章,肯定得用创建哈希数据函数

创建哈希数据

//创建哈希数值类型
HashValue CreateHashValue(Key key, Value value){
	return { key,value };
}

创建哈希数据 之后该插入了

bool HashTableInsert(HashTable& HashTable, HashValue &&Val){

	HashBucket BucketSpace = HashTable.BucketSpace;

	//查找哈希表里的key是否能找到
	HashElement Find = HashTablFind(HashTable, Val.key);

	if (Find){
		RunNotFound(__func__, std::string("调用出现了问题! 问题的 \n") + "原因是" + std::to_string(Val.key) + "存在");
		return false;
	}
	
	int HashIndex = Hash(Val, HashTable);
	HashElement elementList = BucketSpace[HashIndex];
	HashElement Newelement = CreateHashElement(Val, elementList->Next);

	//采用前面插入
	elementList->Next = Newelement;

	return true;
}

首先 查找不用看 一开始有数据可查? 并没有吧 这里就跳过 不要在意这些细节

int HashIndex = Hash(Val, HashTable);

从哈希函数提取哈希表 的 索引

int Hash(const HashValue& hashValue, const HashTable& HashTable){
	return hashValue.key % HashTable.BucketSpaceSize;
}

获取哈希表的元素(当然你们也知道,就不必要介绍这些骚操作)

HashElement elementList = BucketSpace[HashIndex];

你们都懂 就没必要可说的

HashElement Newelement = CreateHashElement(Val, elementList->Next);

//声明  Next默认是空指针
static HashElement CreateHashElement(HashValue& val, LinkNode* Next = nullptr);

static HashElement CreateHashElement(HashValue& val, LinkNode*Next){

	HashElement Element = (LinkNode*)malloc(sizeof(LinkNode));
	if (Element){
		*Element = { val ,Next };
	}
	else{

		std::cout << (std::string(__func__) + "调用失败! 原因是分配内存失败") << std::endl;
		abort();
		
	}

	return Element;
}

优化 创建哈希表函数

bool CreateHashTable(HashTable& HashTable, int BucketSpaceSize) {

	BucketSpaceSize = BucketSpaceSize <= 0 ? default_BucketSpaceSize : (BucketSpaceSize > default_BucketSpaceSize ? BucketSpaceSize : default_BucketSpaceSize);

	HashTable.BucketSpace = CreateHashBucket((HashTable.BucketSpaceSize = BucketSpaceSize));
	if (HashTable.BucketSpace){
		return true;
	}

	HashTable.BucketSpaceSize = 0;
	return  false;

}

增加 CreateHashBucket函数

static  HashBucket CreateHashBucket(size_t& BucketSpaceSize) {
	//分配哈希桶空间
	HashBucket BucketSpace =  (HashElement*)malloc(sizeof(HashBucket) * ( BucketSpaceSize));
	
	HashValue TempVal = {};//创建临时值
	
	if (BucketSpace) {
		//创建哈希元素并且保存到哈希桶空间内
		//初始化哈希桶空间
		for (size_t i = 0; i < B ucketSpaceSize; i++) {
			BucketSpace[i]= CreateHashElement(TempVal);
		}
	}
	return BucketSpace;
}

此操作只是优化 并不代表没有什么,保持原来的就好了

头部插入最简单高效的办法

在这里不考虑扩大,哈希桶的容量

哈希链表查找算法

通过key对应的哈希元素

HashElement HashTablFind(const HashTable& HashTable, Key key){

	HashBucket BucketSpace = HashTable.BucketSpace;
	int HashIndex = Hash({ key }, HashTable);

	HashElement HashElementList = BucketSpace[HashIndex];

	HashElementList = HashElementList->Next;

	while (HashElementList && HashElementList->MyValue.key!=key){
		HashElementList = HashElementList->Next;
	}

	return HashElementList;
}

通过key找到对应的value

Value HashTableKeyToValue(const HashTable& HashTable, Key key){
	
	HashElement Element = HashTablFind(HashTable, key);
	
	if (!Element) {
		RunNotFound(__func__, (std::string(" 函数 出错误 :没有这个键值为: ") + std::to_string(key) + " 的数据"));
		//记住销毁哈希表
		
		abort();
	}

	return Element->MyValue.value;
}

哈希表删除算法

//查找key的元素前驱结点 带删除的结点
static HashElement HashTablFindElementNodePrev(const HashTable& HashTable, Key key,LinkNode*&Node) {

	HashBucket BucketSpace = HashTable.BucketSpace;
	int HashIndex = Hash({ key }, HashTable);

	HashElement HashElementList = BucketSpace[HashIndex];
	HashElement Prev = HashElementList;
	HashElementList = HashElementList->Next;
	Node = nullptr;
	while (HashElementList && HashElementList->MyValue.key != key) {
		Prev = HashElementList;
		HashElementList = HashElementList->Next;
	}
	
	Node = HashElementList;
	return Prev;
}

//哈希表删除算法
void HashTableDelete(HashTable& HashTable, Key key) {

	HashElement DeleteNode;

	HashElement DeleteNodePrev = HashTableFindElementNodePrev(HashTable, key, DeleteNode);

	if (DeleteNode)	{
		DeleteNodePrev->Next = DeleteNode->Next;
		free(DeleteNode);
	}
}

哈希表销毁算法

//
static void HashElementDestroy(HashElement& HashElementList);


void HashTableDestroy(HashTable& HashTable){

	if (HashTable.BucketSpace )	{


		for (size_t i = 0; i < HashTable.BucketSpaceSize; i++) {
			HashElementDestroy(HashTable.BucketSpace[i]);
		}

		free(HashTable.BucketSpace);
		HashTable = {};
	}
}

void HashElementDestroy(HashElement& HashElementList) {

	while (HashElementList) {

		LinkNode* Next = HashElementList->Next;

		free(HashElementList);
		HashElementList = Next;
	}

}

哈希顺序表算法实现

虽然链表方式最骚的实现,但插入和删除效率极高 我也无法反驳 但放松了一个月的我来说:虽然 效率不高但实现起来也并不复杂,但我一直没找到,虽然有二分查找法但用了之后的…就没法展开,所以停顿了一段时间,
(好吧,其实我是玩GPT 还有new Bing 虽然说可能没啥可建议的 但也有点帮助)
总之这一个月.我啥也没干[😂]

哈希顺序表定义

数据定义

 using Key = int;
 using Value = use define;

//哈希数据
struct Hashvalue {
	Key key;
	Value value;
};
//顺序表
struct SeqList {

	Hashvalue *ValueSpace;
	int capacity;
	int size;
};

哈希表定义

//哈希表元素类型
using HashElement = Hashvalue*;

//默认桶空间容量
const int default_BucketSpaceSize = 16;

//哈希桶
using HashBucket =  SeqList*;

//哈希顺序表
struct HashSeqTable {
	HashBucket BucketSpace;//桶空间
	size_t HashTableSize;//桶空间大小
};

哈希顺序表创建算法

//创建顺序表
static bool CreateSeqList(SeqList* HashBucket, int capacity) {

	if (capacity > 0) {
		HashBucket->ValueSpace = (Hashvalue*)malloc(sizeof(Hashvalue) * capacity);
		HashBucket->capacity = capacity;
		HashBucket->size = 0;
		return true;
	}

	return false;
}



//创建哈希表
bool  CreateHashTable(HashSeqTable& HashTable, int  BucketSpaceSize) {

	bool ret = 0;

	BucketSpaceSize = BucketSpaceSize <= 0 ? default_BucketSpaceSize : (BucketSpaceSize > default_BucketSpaceSize ? BucketSpaceSize : default_BucketSpaceSize);
	int	HashTableSize = HashTable.HashTableSize = BucketSpaceSize;
	SeqList* Bucket = (HashBucket)malloc(sizeof(HashBucket) * HashTableSize);

	if (Bucket) {

		for (size_t i = 0; i < HashTableSize; i++) {
			CreateSeqList(Bucket + i, HashTableSize);
		}

		ret = true;
		HashTable.BucketSpace = Bucket;

	}
	return ret;
}

哈希顺序表插入算法

bool ListAppend(SeqList& list, const Hashvalue& val) noexcept(true) {
	bool ret = false;
	if (list.size >= list.capacity) {
		return ret;
	}

	int& size = list.size;

	list.ValueSpace[size] = (val);
	ret = ++size;
	return ret;
}


void HashTableInsertUpdate(HashSeqTable& hashTable, const Hashvalue& value) {


	SeqList* List(hashTable.BucketSpace + Hash(value.key, hashTable));
	ListAppend(*List, value);

}


bool HashTableInsert(HashSeqTable& HashTable, const Hashvalue& value) {

	bool ret = false;
	const HashSeqTable& const_HashTable = HashTable;
	HashElement	 find = HashTableFind(const_HashTable, value.key);
	if (!find) {
		HashTableInsertUpdate(HashTable, value);
		ret = !ret;
	}

	return ret;
}

哈希顺序表查找算法

Hashvalue* IndexFind(const HashSeqTable& HashTable, int HashCode, const HashKey& value){

	SeqList* list = HashTable.BucketSpace + HashCode;
	Hashvalue* dataTable = list->ValueSpace;
	int dataSize = list->size;
	int capacity = list->capacity;

	int index = 0;
	Hashvalue* v = nullptr;
	if (dataSize > 0) {


		while (index != HashCode && dataTable[index].key != value) {

			index = (++index) % capacity;

		}
		v = dataTable[index].key != value ? v : dataTable + index;
	}
	return v;
}


Hashvalue* HashTableFind(const HashSeqTable& hashTable, const HashKey &value) {

	int HashCode = Hash(value , hashTable);

	return 	IndexFind(hashTable, HashCode, value);
}

通过key找到对应的value

// 通过key找到对应的value 
HashValue HashTableKeyToValue(const HashSeqTable& HashTable, HashKey key) {

	Hashvalue* Hashvalue = HashTableFind(HashTable, key);
	if (Hashvalue) {
		return Hashvalue->value;
	}

	return (HashValue)Hashvalue;
}

哈希表删除算法

// 从顺序表中删除目标元素
static void Remove(SeqList& List,  Hashvalue* Target) {

        // 找到顺序表中最后一个元素
        Hashvalue* Last=List.ValueSpace + List.size;

        // 将目标元素后面的元素向前移动一个位置
        HashElement first = Target + 1;
        while (first !=Last){
                *Target = *first;
                ++Target;
                ++first;
        }
        // 顺序表的大小减1
        --List.size;
}


void HashTableDelete(HashSeqTable& HashTable,const HashKey& key){

	SeqList* List = GetHashBucketElement(HashTable, key);
	const HashSeqTable& const_HashTable = HashTable;

	HashElement deleteHashElement = HashTableFind(const_HashTable, key);
	if (deleteHashElement){

		Remove(*List, deleteHashElement);
	}
}

哈希顺序表销毁算法

//销毁顺序表
static void DestroySeqList(SeqList& list) {
	free(list.ValueSpace);
	list.ValueSpace = nullptr;
	list.capacity = 0;
	list.size = 0;
}

void HashTableDestroy(HashSeqTable& HashTable){

	for (int i = 0; i < HashTable.HashTableSize; i++){

		// 调用销毁顺序表函数销毁每个哈希桶中的顺序表
		DestroySeqList(*(HashTable.BucketSpace + i));
	}

	free(HashTable.BucketSpace);

	HashTable = {};

}