C++(数据结构与算法):32---散列(哈希)冲突之链地址法（附编码实现）

• 本文代码下载：
  • 方式1：公众号【多栖技术控小董】回复【3582】免费获取下载链接。
  • 方式2：CSDN下载链接：
    • 编码实现1下载地址：https://download.csdn.net/download/qq_41453285/12034059
    • 编码实现2下载地址：待续
  • 方式3：Github下载链接https://github.com/dongyusheng/Interview-algorithm/tree/master/c%2B%2BAlgorithms（进入之后下载里面的hashChains.zip文件）

一、链地址法

• 散列表基础介绍与散列冲突见文章：https://blog.csdn.net/qq_41453285/article/details/103517420
• 链地址法的基本思想：在散列表的每一个位置分配一个线性表。这样，每一个数对就可以存储在它的起始桶线性表中了
• 链地址法同时也解决了散列表移除的问题
• 例如，下图就是一个散列表，其中产生散列冲突的元素存储在同一个桶链表中了

二、链地址法的增加、删除、查找

查找

• 根据关键字k与散列函数f(k)=k%D，计算起始桶。然后搜索该桶对应的链表

增加：

• 首先保证散列表没有一个记录与该记录的关键字相同，为此而进行的搜索仅限于该记录的起始桶所对应的链表

删除：

• 删除一个关键字为k的记录，先搜索它所对应的起始桶链表，找到该记录然后删除

三、一种改进的实现方法

• 在每个链表上增加一个尾节点，可以改进一些程序的性能
• 尾节点的关键字值最起码要比插入的所有数对的关键字都大
• 有了尾节点就省去了在链表中出现的大部分对空指针的检验操作
• 备注：每个链表都有不同的尾节点，实际上，所有的链表可共用一个尾节点
• 例如在下图中，尾节点的关键字用表示（实际中用整数表示），可以使用limits.h头文件中定义的INT_MAX来替代

 

四、与线性探查法的比较

• 线性探查法见文章：https://blog.csdn.net/qq_41453285/article/details/103533372

五、与跳表的比较

• 跳表见文章：https://blog.csdn.net/qq_41453285/article/details/103449903

六、编码实现1

• 我们在前面用链表实现过字典（sortedChain），因为链地址法中散列表的每一个位置都是一个链表，因此我们可以直接定义一个类，在类中使用前面文章介绍过的sortedChain来实现链地址法
• sortedChain实现见文章：https://blog.csdn.net/qq_41453285/article/details/103449056

头文件定义 

#include <iostream>
#include <string>
#include <utility>

using std::cout;
using std::cin;
using std::endl;
using std::pair;
using std::string;

hash类定义

• 用于将关键字映射为一个整数，便于在散列中进行操作

template<class K> class hash;

template<>
class hash<std::string>
{
public:
	std::size_t operator()(const std::string theKey)const
	{
		unsigned long hashValue = 0;
		int length = (int)theKey.length();
		for (int i = 0; i < length; i++) {
			hashValue = hashValue * 5 + theKey.at(i);
		}

		return std::size_t(hashValue);
	}
};

template<>
class hash<int>
{
public:
	std::size_t operator()(const int theKey) const
	{
		return std::size_t(theKey);
	}
};

template<>
class hash<long>
{
public:
	std::size_t operator()(const long theKey) const
	{
		return std::size_t(theKey);
	}
};

字典链表定义

• 链地址法中，散列表的每一个位置都是一个链表，链表就使用下面的sortedChain表示

template<class K,class E>
struct pairNode
{
	typedef std::pair<const K, E> pairType;

	pairType element;
	struct pairNode<K,E>* next;

	pairNode(const pairType& thePair):element(thePair) {}
	pairNode(const pairType& thePair, struct pairNode<K, E>* theNext) :element(thePair) { this->next = theNext; }
};


template<class K, class E>
class sortedChain :public dictionary<K, E>
{
public:
	sortedChain();
	~sortedChain();
	bool empty()const override;
	int size()const override;
	std::pair<const K, E>* find(const K& theKey)const override;
	void erase(const K& theKey) override;
	void insert(const std::pair<const K, E>& thePair) override;

	void output(std::ostream &out)const;
private:
	pairNode<K, E>* firstNode;
	int dSize;
};

template<class K, class E>
sortedChain<K, E>::sortedChain()
{
	this->firstNode = nullptr;
	this->dSize = 0;
}

template<class K, class E>
sortedChain<K, E>::~sortedChain()
{
	pairNode<K, E>* tempNode;
	while (this->firstNode) {
		tempNode = this->firstNode->next;
		delete this->firstNode;
		this->firstNode = tempNode;
	}
}

template<class K, class E>
bool sortedChain<K, E>::empty()const
{
	return this->dSize == 0;
}

template<class K, class E>
int sortedChain<K, E>::size()const
{
	return this->dSize;
}

template<class K, class E>
std::pair<const K, E>* sortedChain<K, E>::find(const K& theKey)const
{
	pairNode<K, E>* tempNode = this->firstNode;

	//遍历字典
	while ((tempNode != nullptr) && (tempNode->element.first != theKey))
		tempNode = tempNode->next;

	//如果找到了就返回
	if ((tempNode != nullptr) && (tempNode->element.first == theKey))
		return &tempNode->element;

	//没有找到就返回空
	return nullptr;
}

template<class K, class E>
void sortedChain<K, E>::erase(const K& theKey)
{
	pairNode<K, E>* eraseNode = this->firstNode;
	pairNode<K, E>* beforeEraseNode = nullptr;

	//遍历字典
	while ((eraseNode != nullptr) && (eraseNode->element.first < theKey))
	{
		beforeEraseNode = eraseNode;
		eraseNode = eraseNode->next;
	}

	//找到了就删除
	if ((eraseNode != nullptr) && (eraseNode->element.first == theKey))
	{
		//如果删除的是头结点
		if (eraseNode == this->firstNode) {
			this->firstNode = eraseNode->next;
		}
		else {
			beforeEraseNode->next = eraseNode->next;
		}
		delete eraseNode;
		this->dSize--;
	}
}

template<class K, class E>
void sortedChain<K, E>::insert(const std::pair<const K, E>& thePair)
{
	pairNode<K, E>* afterInsertNode = this->firstNode;
	pairNode<K, E>* beforeInsertNode = nullptr;

	//遍历字典
	while ((afterInsertNode != nullptr) && (afterInsertNode->element.first < thePair.first))
	{
		beforeInsertNode = afterInsertNode;
		afterInsertNode = afterInsertNode->next;
	}

	//如果键已经存在，更新值
	if ((afterInsertNode != nullptr) && (afterInsertNode->element.first == thePair.first))
	{
		afterInsertNode->element.second = thePair.second;
		return;
	}

	//如果键不存在，插入新节点
	pairNode<K, E>* insertNode = new pairNode<K, E>(thePair, afterInsertNode);
	if (beforeInsertNode == nullptr)
		this->firstNode = insertNode;
	else
		beforeInsertNode->next = insertNode;
	this->dSize++;
}

template<class K, class E>
void sortedChain<K, E>::output(std::ostream &out)const
{
	for (pairNode<K, E>* tempNode = this->firstNode; tempNode != nullptr; tempNode = tempNode->next) {
		out << "key:" << tempNode->element.first << ",value:" << tempNode->element.second << std::endl;
	}
}

template<class K,class E>
std::ostream& operator<<(std::ostream& out,const sortedChain<K,E>& theChain)
{
	theChain.output(out);
	return out;
}

散列表的最终实现 

template<class K,class E>
class dictionary
{
public:
	virtual ~dictionary(){}
	virtual bool empty()const = 0;
	virtual int size()const = 0;
	virtual std::pair<const K, E>* find(const K& theKey)const = 0;
	virtual void erase(const K& theKey) = 0;
	virtual void insert(const std::pair<const K, E>& thePair) = 0;
};

template<class K,class E>
class hashChains :public dictionary<K, E>
{
public:
	hashChains(int theDivisor=11);
	~hashChains();
	bool empty()const override;
	int size()const override;
	std::pair<const K, E>* find(const K& theKey)const override;
	void erase(const K& theKey) override;
	void insert(const std::pair<const K, E>& thePair) override;

	void output(std::ostream & out)const;
private:
	sortedChain<K, E>* table;
	hash<K> hash;  //将关键字映射为一个整数
	int dSize;     //哈希表的大小
	int divisor;   //哈希函数的除数
};

template<class K, class E>
hashChains<K, E>::hashChains(int theDivisor = 11)
{
	this->divisor = theDivisor;
	this->dSize = 0;

	this->table = new sortedChain<K, E>[theDivisor];
}

template<class K, class E>
hashChains<K, E>::~hashChains()
{
	if (this->table) {
		delete[] this->table;
		this->table = nullptr;
	}
}

template<class K, class E>
bool hashChains<K, E>::empty()const
{
	return (this->dSize == 0);
}

template<class K, class E>
int hashChains<K, E>::size()const
{
	return this->dSize;
}

template<class K, class E>
std::pair<const K, E>* hashChains<K, E>::find(const K& theKey)const
{
	int index = hash(theKey) % this->divisor;
	return this->table[index].find(theKey);
}

template<class K, class E>
void hashChains<K, E>::erase(const K& theKey)
{
	int index = hash(theKey) % this->divisor;
	this->table[index].erase(theKey);
}

template<class K, class E>
void hashChains<K, E>::insert(const std::pair<const K, E>& thePair)
{
	int bucketIndex = hash(thePair.first) % this->divisor;
	int homeSize = this->table[bucketIndex].size();
	this->table[bucketIndex].insert(thePair);

	//如果insert操作不是替换值，而是插入新值，那么就增加元素个数
	if (this->table[bucketIndex].size() > this->dSize) {
		this->dSize++;
	}
}

template<class K, class E>
void hashChains<K, E>::output(std::ostream & out)const
{
	for (int i = 0; i < this->divisor; ++i) {
		if (this->table[i].empty())
			std::cout << "NULL" << std::endl;
		else
			std::cout << this->table[i];
	}
}

template<class K,class E>
std::ostream& operator<<(std::ostream &out,const hashChains<K,E>& theHashChains)
{
	theHashChains.output(out);
	return out;
}

主函数

int main()
{
	hashChains<int, int>* myHashChains = new hashChains<int, int>(11);
	
	myHashChains->insert(std::pair<int, int>(1, 1));
	myHashChains->insert(std::pair<int, int>(2, 2));
	myHashChains->insert(std::pair<int, int>(3, 3));

	std::cout << myHashChains;

	return 0;
}

七、编码实现2

• 待续