C++数据结构：散列表简单实现（hash表）

C++数据结构

线性顺序表（数组）
线性顺序表（链表）
Python风格双向链表的实现
散列表简单实现（hash表）
栈和队列的应用
二叉树之一（数组存储）
二叉树之二（二叉搜索树）
二叉树之三（二叉搜索树扩展）
图结构入门

---

---

前言

散列表是一种常用的数据结构，它可以快速地存储和查找数据。散列表的基本思想是，将数据的关键字映射到一个有限的地址空间中，然后在该地址空间中存储数据。这样，当需要查找某个数据时，只需要计算其关键字的映射地址，然后在该地址处访问数据，从而实现高效的查找操作。

一、设计思想

散列表的核心是散列函数，也称为哈希函数。散列函数的作用是，将任意长度的关键字转换为一个固定长度的地址，这个地址就是散列值或哈希值。散列函数应该满足以下几个要求：

• 一致性：相同的关键字应该产生相同的散列值。

• 高效性：散列函数的计算应该简单快速，不占用过多的时间和空间。

• 均匀性：散列函数应该尽可能地将关键字均匀地分布在地址空间中，避免产生冲突。冲突是指不同的关键字映射到相同的地址的情况，这是不可避免的。因此，散列表还需要一个解决冲突的方法。常用的解决冲突的方法有两种：

• 开放寻址法：当发生冲突时，按照某种规则在地址空间中寻找下一个空闲的位置，直到找到或者遍历完整个地址空间为止。这种方法需要保证地址空间有足够的容量，否则会导致插入失败或者查找效率降低。

• 链地址法：当发生冲突时，将具有相同地址的数据组织成一个链表，每个地址处只存储链表的头指针。这种方法不受地址空间大小的限制，但是需要额外的空间存储链表节点。

下面我们用C++实现一个简单的散列表，采用除留余数法作为散列函数，采用链地址法作为解决冲突的方法。除留余数法是指，将关键字除以一个素数p，然后取余数作为散列值。我们假设关键字是整数类型，素数p是10（也可以不是素数，但因为不是素数能被更多的数整除，冲突概率大，所以文中用了1，3，7，11做演示），地址空间大小也是10。

二、实现步骤

首先，我们定义一个链表节点类Node，用来存储数据和指向下一个节点的指针：

1、定义节点

这是一个链表的节点定义，它的作用是存储同一hash值（也叫散列值）的数据，所以它有next指向下一个节点，从设计思想来看，hash函数设计得越好，这个单向链表越短，那么效率就越高。最差情况当然就是所有的数据经过hash函数计算后的值都一样，那就成了一个单向链表，这种情况是一定要避免的。

class Node{
	public:
		int key;        //键
		int value;      //值
		Node* next;            //指向下一个结点的指针
		Node(int k, int v){    //构造函数
			key = k;
			value = v;
			next = nullptr;
		}
};

2、定义Hash表类

然后我们定义一个散列表类，用来管理结点和提供基本的操作：
int hash(int key)，这个就是散列函数，它只简单计算了余数。对于散列函数来说，应在hash值尽量分布均匀的基础上设计简单点，不然把大把时间都花在计算hash值上了。这里是以整数作为例子的，所以直接模运算了，实际泛型编程要考虑其它类型数据的hash值计算。

class HashTable{
	private:
		int capacity;   //数组的容量
		int size;       //当前存储的键值对的数量
		Node** array;   //指向数组的指针
		int hash(int key){    //散列函数，简单地取模
			return key % capacity;
		}
		
	public:
		HashTable(int c){   //构造函数，初始化数组和其他变量
			capacity = c;
			size = 0;
			array = new Node*[capacity];
			for (int i = 0; i < capacity; i++){
				array[i] = nullptr;
			}
		}
		
		~HashTable(){       //析构函数，释放内存
			for (int i = 0; i < capacity; i++){
				Node* cur = array[i];
				while (cur != nullptr){
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
			}
			delete[] array;
		}

以上代码定义了散列表，就是一个构造函数和析构函数，比较简单。有一定C++语言基础的都能看明白，既然来看这篇文章了，肯定是有C++基础的。

Node** array; //指向数组的指针 这是一个二级指针，指向一个存放指针的数组。这个数组的下标就是我们hash计算的目标。这个数组中存放了每个链表的链表头节点。

		
	    void insert(int key, int value){      //插入操作
	        int index = hash(key);           //计算键对应的位置
	        Node* cur = array[index];        //获取该位置的链表头结点
	        while (cur != nullptr){         //遍历链表，查找是否已经存在相同的键
	            if (cur->key == key){       //如果存在，更新值并返回
	                cur->value = value;
	                return;
	            }
	            cur = cur->next;
	        }
	        //如果不存在，创建新的结点，并插入到链表头部
	        Node* newNode = new Node(key, value);
	        newNode->next = array[index];
	        array[index] = newNode;
	        size++;          //更新键值对数量
	    }
    
	    int get(int key){          //查找操作
	        int index = hash(key);    //计算键对应的位置
	        Node* cur = array[index];  //获取该位置的链表头结点
	        while (cur != nullptr){      //遍历链表，查找是否存在相同的键
	            if (cur->key == key){    //如果存在，返回值
	                return cur->value;
	            }
	            cur = cur->next;
	        }
	        //如果不存在，返回-1表示错误
	        return -1;
	    }

以上是插入、取值的操作，具体看注释就明白实现过程了。
以下是删除键值对的方法，因为实际存储数据是单向链表，所以删除操作时要记录上一个节点的指针，略微麻烦一点。

	    void remove(int key){      //删除操作
	        int index = hash(key);    //计算键对应的位置
	        Node* cur = array[index];   //获取该位置的链表头结点
	        Node* prev = nullptr;       //记录前一个结点的指针
	        while (cur != nullptr) {    //遍历链表，查找是否存在相同的键
	            if (cur->key == key){      //如果存在，删除结点，并更新链表和数组
	                if (prev == nullptr){     //如果是头结点，直接更新数组
	                    array[index] = cur->next;
	                } else {                 //如果不是头结点，更新前一个结点的指针
	                prev->next = cur->next;
	                }
	                delete cur;       //释放内存
	                size--;           //更新键值对数量
	                return;
	            }
	            prev = cur;         //更新前一个结点的指针
	            cur = cur->next;       //移动到下一个结点
	        }
	        //如果不存在，不做任何操作
	    }
};

以上是具体功能实现的函数，和前面链表的功能有很多相似之处。加上代码的详细注释，相信是很容易看明白的。流程很简单，根据传入的 key ，用 hash 函数计算得到一个值，因为是模运算，这个值肯定在0到9之间（这里以10为例，事实上也可以是任何其它正整数），就以这个余数作为arrary数组的下标，这个数组中存储的又是一个单向链表的头节点。我们就到这个链表中去具体匹配是哪个节点进行增加删除工作。

三、数据示例

以上就是我们用C++实现的散列表类。我们可以用以下代码测试它的功能：

#include <iostream>
using namespace std;

int main(){
    HashTable ht(13); // 创建一个容量为10的散列表对象

	ht.insert(1, 10); // 插入一些键值对
	ht.insert(7, 20);
	ht.insert(3, 30);
	ht.insert(11, 110);

	cout << ht.get(1) << endl; // 查找一些键，并打印结果
    cout << ht.get(7) << endl;
	cout << ht.get(3) << endl;
	cout << ht.get(11) << endl;

	ht.remove(2); // 删除一个键

	cout << ht.get(2) << endl; // 再次查找该键，并打印结果

	return 0;
}

输出结果如下：

10
20
30
110
-1

根据程序设计，要求“键”和“值”都是整数。所以我们传入的参数是两个整数。ht.insert(1, 10); // 插入一些键值对，这里的参数1是作为key的，参数10是作为value的。散列表还有个不正规的名字叫“键值对”。它是根据“键”去确定“值”存储位置的，当然也根据“键”去取“值”。设计优秀的散列表存取速度是很快的。它和数据库的设计思想是有相通之处的。所以在示例中，和图上画的一样，“key”：1 和“key”：11 都是存在下标为1的数组指针指向的链表，根本不存在下标为11的情况。而ht.get(2)hash计算的结果是2，数组下标2是空指针，所以输出是-1。

---

总结

可以看到，我们实现的散列表可以正确地执行插入、查找和删除操作。当然，这只是一个简单的示例，实际上还有很多细节和优化可以考虑。例如，如何选择合适的散列函数和容量？如何动态地调整容量？如何处理负数或其他类型的键？如何提高代码的可读性和可维护性？等等。这些问题都可以作为进一步学习和探索的方向。