《剑指 Offer》专项突破版 - 面试题 30 和 31：详解如何设计哈希表以及利用哈希表设计更加高级、复杂的数据结构

目录

一、哈希表的基础知识

二、哈希表的设计

2.1 - 插入、删除和随机访问都是 O(1) 的容器

2.2 - 最近最少使用缓存

一、哈希表的基础知识

哈希表是一种常见的数据结构，在解决算法面试题的时候经常需要用到哈希表。哈希表最大的优点是高效，在哈希表中插入、删除或查找一个元素都只需要 O(1) 的时间。因此，哈希表经常被用来优化时间效率。

在 C++ 中，哈希表有两个对应的类型，即 unordered_set 和 unordered_map。如果每个元素都只有一个值，则用 unordered_set。例如，unordered_set 在图搜索时经常用来存储已经搜索过的节点。如果每个元素都存在一个值到另一个值的映射，那么就用 unordered_map。例如，如果要存储一个文档中的所有单词，同时还关心每个单词在文档中出现的位置，则可以考虑用 unordered_map，单词作为 unordered_map 的键而单词的位置作为值。

尽管哈希表是很高效的数据结构，但这并不意味着哈希表能解决所有的问题。如果用哈希表作为字典存储若干单词，那么只能输入完整的单词在字典中查找。如果对数据集中的元素排序能够有助于解决问题，那么用 set 或 map（第 8 章）可能更合适。如果需要知道一个动态数据集中的最大值或最小值，那么堆（第 9 章）的效率可能更好。如果希望能够根据前缀进行单词查找，如查找字典中所有以 "ex" 开头的单词，那么应该用前缀树（第 10 章）作为实现字典的数据结构。

二、哈希表的设计

与链表、数组等基础数据结构相比，哈希表相对而言要复杂得多。如何设计一个哈希表，是很多面试官非常喜欢的面试题。下面简要地介绍设计一个哈希表的要点。

设计哈希表的前提是待存入的元素需要一个能计算自己哈希值的函数。哈希表根据每个元素的哈希值把它存储到合适的位置。

template<class K>
struct DefaultHashFunc
{size_t operator()(const K& key){return (size_t)key;}
};
​
template<>
struct DefaultHashFunc<std::string>
{size_t operator()(const std::string& str){// BKDRHashsize_t hash = 0;size_t seed = 131;for (char ch : str){hash = hash * seed + ch;}return hash;}
};

哈希表最重要的特点就是高效，只需要 O(1) 的时间就可以把一个元素存入或读取。在常用的基础数据结构中，数组满足这个要求。只要知道数组中的下标，就可以用 O(1) 的时间存入或读取一个元素。因此，可以考虑基于数组实现哈希表。

把哈希值转换成数组下标可以采用的方法是对数组的长度求余数。如果数组的长度是 4，待存入的元素的哈希值为 5，由于 5 除以 4 的余数是 1，那么它将存入数组下标为 1 的位置。同理，如果待存入的元素的哈希值为 2 和 3，那么它们分别存入下标为 2 和 3 的位置。此时哈希表的状态如下图 (a) 所示。

再在哈希表中存入一个哈希值为 7 的元素。由于 7 除以 4 的余数为 3，因此它存入的位置应该是 3。下标为 3 的位置之前已经被哈希值为 3 的元素占用。如果将两个哈希值不同的元素存入数组中的同一个位置，会引发冲突。

为了解决这种冲突，可以把存入数组中同一个位置的多个元素用链表存储。也就是说，数组中每个位置对应的不是一个元素，而是一个链表。哈希值为 3 和 7 的两个元素都存放在数组下标为 3 的位置，因此它们实际上存入了同一个链表中。接下来如果再添加哈希值分别为 4 和 8 的两个元素，那么它们都将被存入数组下标为 0 的位置对应的链表中。此时哈希表的状态如下图 (b) 所示。不难想象，如果在哈希表中添加更多的元素，那么就会有更多的冲突，有更多的元素被存入同一个链表中。

接着考虑如何判断哈希表中是否包含一个元素。例如，为了判断哈希表中是否包含哈希值为 7 的元素，由于 7 除以 4 的余数是 3，因此先找到数组下标为 3 的位置对应的链表，然后从头到尾扫描这个链表查看是否有哈希值为 7 的元素。

在链表中做顺序扫描的时间复杂度为 O(n)，链表越长查找需要的时间就越长。这就违背了设计哈希表最重要的一个初衷：存入和读取一个元素的时间复杂度为 O(1)。因此，必须确保链表不能太长。

可以计算哈希表中元素的数目与数组长度的比值。显然，在数组长度一定的情况下，存入的元素越多，这个比值就越大；在存入元素的数目一定的情况下，数组的长度越长，这个比值就越小。

当哈希表中元素的数目与数组长度的比值超过某一阈值时，就对数组进行扩容（通常让数组的长度翻倍），然后把哈希表中的每个元素根据新的数组大小求余并存入合适的位置。例如，在下图 (c) 中，扩容之后数组的长度为 8，这个时候原本存入同一链表的 3 和 7 被分别存入下标为 3 和 7 的位置。

通过对数组进行扩容，原本存入同一链表的不同元素就可能会被分散到不同的位置，从而减少链表的长度。当再在哈希表中添加新的元素时，元素的数目与数组长度的比较可能会再次超过阈值，于是需要再次对数组进行扩容。只要阈值设置得合理，哈希表中的链表就不会太长，仍然可以认为存入和读取的时间复杂度都是 O(1)。

由此可知，设计哈希表有以下 3 个要点：

  1. 为了快速确定一个元素在哈希表中的位置，可以使用一个数组，元素的位置为它的哈希值除以数组长度的余数。

  2. 由于多个哈希值不同的元素可能会被存入同一位置，数组的每个位置都对应一个链表，因此存入同一个位置的多个元素都被添加到同一链表中。

  3. 为了确保链表不会太长，就需要计算哈希表中元素的数目与数组长度的比值。当这个比值超过某个阈值时，就对数组进行扩容并把哈希表中的所有元素重新分配位置。

template<class T>
struct HashNode
{T _data;HashNode<T>* _next;
​HashNode(const T& data): _data(data), _next(nullptr){ }
};
​
template<class K, class T, class KOfT, class HashFunc = DefaultHashFunc<K>>
class HashTable
{typedef HashNode<T> Node;
private:/*---------- 数组的长度最好是素数 ----------*/static size_t GetNextPrime(size_t prime){const int PRIMECOUNT = 28;static const size_t primeList[PRIMECOUNT] ={53, 97, 193, 389, 769,1543, 3079, 6151, 12289, 24593,49157, 98317, 196613, 393241, 786433,1572869, 3145739, 6291469, 12582917, 25165843,50331653, 100663319, 201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};
​size_t i = 0;for (; i < PRIMECOUNT; ++i){if (primeList[i] > prime)return primeList[i];}return primeList[i];}
public:/*---------- 构造函数和析构函数 ----------*/HashTable(): _table(GetNextPrime(0), nullptr), _size(0){ }
​~HashTable(){for (size_t i = 0; i < _table.size(); ++i){Node* cur = _table[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_table[i] = nullptr;}}
​/*---------- 查找 ----------*/bool find(const K& key){HashFunc hf;size_t hashAddr = hf(key) % _table.size();Node* cur = _table[hashAddr];KOfT kot;while (cur){if (kot(cur->data) == key)return true;cur = cur->_next;}return false;}
​/*---------- 插入 ----------*/bool insert(const T& data){KOfT kot;if (find(kot(data)) == true)return false;HashFunc hf;size_t hashAddr = hf(kot(data)) % _table.size();// 头插Node* newNode = new Node(data);newNode->_next = _table[hashAddr];_table[hashAddr] = newNode;++_size;
​// 将装载因子限制在 1 以下if (_size == _table.size()){size_t newSize = GetNextPrime(_table.size());std::vector<Node*> newTable(newSize, nullptr);for (size_t i = 0; i < _table.size(); ++i){Node* cur = _table[i];while (cur){Node* next = cur->_next;// 将 *cur 头插到新表中size_t hashAddr = hf(kot(cur->data)) % newSize;cur->_next = newTable[hashAddr];newTable[hashAddr] = cur;// 更新 curcur = next;}_table[i] = nullptr;}_table.swap(newTable);}return true;}
​/*---------- 删除 ----------*/bool erase(const K& key){HashFunc hf;size_t hashAddr = hf(key) % _table.size();Node* prev = nullptr;Node* cur = _table[hashAddr];KOfT kot;while (cur){if (kot(cur->_data) == key){if (prev == nullptr)  // 头删_table[hashAddr] = cur->_next;elseprev->_next = cur->_next;
​delete cur;--_size;return true;}
​prev = cur;cur = cur->_next;}return false;}
private:std::vector<Node*> _table;  // 哈希表size_t _size;  // 哈希表中存入的元素个数
};

除了设计哈希表本身，利用哈希表设计更加高级、更加复杂的数据结构也是一种常见的面试题。下面是几道这种类型的经典面试题。

2.1 - 插入、删除和随机访问都是 O(1) 的容器

题目：

设计一个数据结构，使如下 3 个操作的时间复杂度都是 O(1)。

  • insert(value)：如果数据集中不包含一个数值，则把它添加到数据集中。

  • remove(value)：如果数据集中包含一个数值，则把它删除。

  • getRandom()：随机返回数据集中的一个数值，要求数据集中每个数值被返回的概率都相同。

分析：

由于题目要求插入和删除（包括数据集中是否包含一个数值）的时间复杂度都是 O(1)，能够同时满足这些时间效率要求的只有哈希表，因此这个数据结构要用到哈希表。

但是如果只用哈希表，则不能等概率地返回其中的每个数值。如果数值是保存在数组中的，那么很容易实现等概率返回数组中的每个数值。假设数组的长度是 n，那么等概率随机生成 0 到 n - 1 的一个数字。如果生成的随机数是 i，则返回数组中下标为 i 的数值。因此可以发现，需要结合哈希表和数组的特性来设计这个数据容器。

由于数值保存在数组中，因此需要知道每个数值在数组中的位置，否则在删除的时候就必须顺序扫描整个数组才能找到待删除的数值，那么就需要 O(n) 的时间。通常把每个数值在数组中的位置信息保存到一个 unordered_map 中，unordered_map 的键是数值，而对应的值为它在数组中的位置。

下面是这种思路的参考代码。在数据容器 RandomizedSet 中，数值保存在用 vector 实现的动态数组 nums 中，而用 unordered_map 实现的哈希表 numToIndex 中存储了每个数值及其在数组 nums 中的下标。

代码实现：

class RandomizedSet {
public:bool insert(int val) {if (numToIndex.count(val) == 1)return false;nums.push_back(val);numToIndex[val] = nums.size() - 1;return true;}
​bool remove(int val) {if (numToIndex.count(val) == 0)return false;// 避免在数组中删除数组的时候移动数据int removeIndex = numToIndex[val];int lastVal = nums[nums.size() - 1];
​nums[removeIndex] = lastVal;nums.pop_back();
​numToIndex[lastVal] = removeIndex;numToIndex.erase(val);return true;}int getRandom() {int i = rand() % nums.size();return nums[i];}
private:vector<int> nums;unordered_map<int, int> numToIndex;
};

2.2 - 最近最少使用缓存

题目：

请设计实现一个最近最少使用（Least Recently Used, LRU）缓存，要求如下两个操作的时间复杂度都是 O(1)。

  • get(key)：如果缓存中存在键 key，则返回它对应的值；否则返回 -1。

  • put(key, value)：如果缓存中之前包含键 key，则它的值设为 value；否则添加键 key 及对应的值 value。在添加一个键时，如果缓存容量已经满了，则在添加新键之前删除最少使用的键（缓存中最长时间没有被使用过的元素）。

分析：

使用哈希表可以让 get 操作和 put 操作的时间复杂度都是 O(1)，但普通的哈希表无法找出最近最少使用的键，因此，需要在哈希表的基础上进行改进。

由于需要知道缓存中最近最少使用的元素，因此可以把存入的元素按访问的先后顺序存入链表中。每次访问一个元素（无论是通过 get 操作还是通过 put 操作），该元素都被移到链表的尾部。这样，位于链表头部的元素就是最近最少使用的。

下面考虑如何实现把一个节点移到链表的尾部。这实际上包含两个步骤，首先要把节点从原来的位置删除，然后把它添加到链表的尾部。需要注意的是，在链表中删除一个节点，实际上是把它的前一个节点的 next 指针指向它的下一个节点。如果这个链表是单向链表，那么找到一个节点的前一个节点需要从链表的头节点开始顺序扫描每个节点，也就需要 O(n) 的时间。

为了快速找到一个节点的前一个节点从而实现用 O(1) 的时间删除一个节点，可以用双向链表来存储缓存中的元素。在双向链表中查找一个节点的前一个节点只需要顺着 prev 指针向前走一步，时间复杂度是 O(1)。

因此，设计最近最少使用缓存需要结合哈希表和双向链表的特点。哈希表的键就是缓存的键，哈希表的值为指向双向链表中的节点的指针，每个节点都是一组键与值的数对。

例如，在一个容量为 4（即最多只能插入 4 个键）的最近最少使用缓存中依次插入 (1, 1)、(2, 2)、(3, 3) 和 (4, 4) 这 4 个键与值的数对之后，先后在双向链表中插入 4 个节点，如下图 (a) 所示。此时最近最少使用的键是 1，它的节点位于链表的头部。

先执行 get(2)。该操作访问键 2，因此它在双向链表中的节点被移到链表的尾部，如下图 (b) 所示。此时最近最少使用的键仍然是 1。

然后执行 put(1, 8)，即更新键 1 对应的值。这个操作访问键 1，因此它在链表中的节点被移到了链表的尾部，如下图 (c) 所示。此时最近最少使用的键是 3。

最后执行 put(5, 5)，插入一个新的键 5。由于此时缓存已满，在插入新的键之前要把最近最少使用的键 3 及其对应的值删除。位于链表的最前面的节点的键是 3，将键 3 及其对应的值从哈希表和双向链表中删除之后，再把键 5 添加到哈希表中，同时在链表的尾部插入一个新的节点，如下图 (d) 所示。

代码实现：

// 双向链表中的节点的定义
struct Node {int k;int v;Node* prev;Node* next;
​Node(int key = 0, int value = 0) : k(key), v(value), prev(nullptr), next(nullptr){ }
};
​
class LRUCache {
public:LRUCache(int capacity): cap(capacity){head = new Node;tail = new Node;head->next = tail;tail->prev = head;}
​int get(int key) {if (mp.count(key) == 0)return -1;
​Node* node = mp[key];moveToTail(node);return node->v;}
​void put(int key, int value) {if (mp.count(key) == 1){Node* node = mp[key];node->v = value;moveToTail(node);return;}if (mp.size() == cap){Node* node = head->next;removeNode(head->next);mp.erase(node->k);}Node* newNode = new Node(key, value);addToTail(newNode);mp[key] = newNode;}
private:void moveToTail(Node* node) {removeNode(node);addToTail(node);}
​void removeNode(Node* node) {node->prev->next = node->next;node->next->prev = node->prev;}
​void addToTail(Node* node) {tail->prev->next = node;node->prev = tail->prev;tail->prev = node;node->next = tail;}
private:unordered_map<int, Node*> mp;// 为了便于在双向链表中添加和删除节点，增加两个哨兵位节点 head 和 tailNode* head;Node* tail;int cap;
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/462057.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Python算法题集_搜索二维矩阵II

Python算法题集_搜索二维矩阵II

Python算法题集_搜索二维矩阵II 题41&#xff1a;搜索二维矩阵II1. 示例说明2. 题目解析- 题意分解- 优化思路- 测量工具 3. 代码展开1) 标准求解【双层循环】2) 改进版一【行尾检测】3) 改进版二【对角线划分】 4. 最优算法 本文为Python算法题集之一的代码示例 题41&#xf…
阅读更多...
政安晨：政安晨：机器学习快速入门（三）{pandas与scikit-learn} {模型验证及欠拟合与过拟合}

政安晨：政安晨：机器学习快速入门（三）{pandas与scikit-learn} {模型验证及欠拟合与过拟合}

这一篇中&#xff0c;咱们使用Pandas与Scikit-liarn工具进行一下模型验证&#xff0c;之后再顺势了解一些过拟合与欠拟合&#xff0c;这是您逐渐深入机器学习的开始&#xff01; 模型验证 评估您的模型性能&#xff0c;以便测试和比较其他选择。 在上一篇中&#xff0c;您已经…
阅读更多...
网络请求库axios

网络请求库axios

一、认识Axios库 为什么选择axios? 功能特点: 在浏览器中发送 XMLHttpRequests 请求在 node.js 中发送 http请求支持 Promise API拦截请求和响应转换请求和响应数据 补充: axios名称的由来? 个人理解没有具体的翻译. axios: ajax i/o system 二、axios发送请求 1.axios请求…
阅读更多...
github拉取项目，pycharm配置远程服务器环境

github拉取项目，pycharm配置远程服务器环境

拉取项目 从github上拉取项目到pycharmpycharm右下角选择远程服务器上的环境 2.1. 如图 2.2. 输入远程服务器的host&#xff0c;port&#xff0c;username&#xff0c;password连接 2.3. 选择服务器上的环境 链接第3点 注&#xff1a;如果服务器上环境不存在&#xff0c;先创建…
阅读更多...
Qt简易登录界面

Qt简易登录界面

代码&#xff1a; #include "mywidget.h" #include "ui_mywidget.h"MyWidget::MyWidget(QWidget *parent): QWidget(parent), ui(new Ui::MyWidget) {ui->setupUi(this);ui->background->setPixmap(QPixmap(":/qt picture/logo.png"))…
阅读更多...
单片机学习笔记---串口向电脑发送数据电脑通过串口控制LED

单片机学习笔记---串口向电脑发送数据电脑通过串口控制LED

目录 串口向电脑发送数据 每隔一秒串口就发送一个递增的数给电脑 电脑通过串口控制LED 波特率的具体计算 HEX模式和文本模式 前两节是本节的理论基础&#xff0c;这节开始代码演示&#xff01; 串口向电脑发送数据 接下来先开始演示一下串口单向发送一个数字给电脑&…
阅读更多...
【学习笔记】TypeScript编译选项

【学习笔记】TypeScript编译选项

TS 中的编译选项 我们写了一个TS的文件&#xff0c;我们需要使用如下的命令将我们的TS文件转换为JS文件。 tsc xxx.ts 这样会产生一个对应的js文件 自动编译文件 编译文件时&#xff0c;使用 -W 指令后&#xff0c;TS编译器会自动监视文件的变化&#xff0c;并在文件发生变…
阅读更多...
[HTTP协议]应用层的HTTP 协议介绍

[HTTP协议]应用层的HTTP 协议介绍

目录 1.前言 2.使用fiddler抓包来观察HTTP协议格式 3.HTTP协议的基本格式 2.1请求 2,1.1首行 2.1.2请求头 2.1.3空行 2.2响应 2.2.1首行 2.2.2响应头 键值对 ​编辑2.2.3空行 2.2.4载荷(响应正文) 3.认识URL 3.1关于URL encode 1.前言 我们在前面的博客中,简单的…
阅读更多...
windows编程-系统编程入门

windows编程-系统编程入门

1.进程线程概念&#xff08;简略版&#xff09; 1.1 进程 1.1.1 概念 我们编写的代码只是一个存储在硬盘的静态文件&#xff0c;通过编译后就会生成二进制可执行文件&#xff0c;当我们运行这个可执行文件后&#xff0c;它会被装载到内存中&#xff0c;接着 CPU 会执行程序中…
阅读更多...
【C++】初识模板：函数模板和类模板

【C++】初识模板：函数模板和类模板

目录 一、模板函数 1、函数模板的概念 2、函数模板的格式 3、函数模板的原理 4、函数模板实例化 5、 模板参数的匹配原则 二、类模板 1 、类模板的定义格式 2 、类模板的实例化 3、模板类示例 一、模板函数 1、函数模板的概念 函数模板代表了一个函数家族&#xff0c…
阅读更多...
堆的概念实现

堆的概念实现

前言 本文将详细讲解堆。堆是一种二叉树&#xff08;一般是完全二叉树&#xff09;使用顺序结构的数组来存储。 tip&#xff1a;这里我们需要注意区分堆在不同地方的含义&#xff0c;这里的堆是一个数据结构&#xff0c;操作系统虚拟进程地址空间的堆是操作系统中管理内存的一块…
阅读更多...
备战蓝桥杯---动态规划之背包问题引入

备战蓝桥杯---动态规划之背包问题引入

先看一个背包问题的简单版&#xff1a; 如果我们暴力枚举可能会超时。 但我们想一想&#xff0c;我们其实不关心怎么放&#xff0c;我们关心的是放后剩下的体积。 用可行性描述即可。 于是我们令f[i][j]表示前i个物品能否放满体积为j的背包。 f[i][j]f[i-1][j]||f[i-1][j-v…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023