知识点十：散列表（下）

前言

散列表和链表这两种数据结构，经常会被放在一起使用。在链表那一节，我们知道了如何用链表来实现 LRU 缓存淘汰算法，但是链表实现的 LRU 缓存淘汰算法的时间复杂度是 O(n)，当时也提到了我们可以继续优化这个实现思路，比如引入散列表（Hash table）来记录每个数据的位置，将缓存访问的时间复杂度降到 O(1)；在跳表那一节，我们讲到 Redis 的有序集合是使用跳表来实现的，跳表可以看作是一种改进版的链表，Redis 有序集合不仅使用了跳表，还用到了散列表；除此之外，Java 编程语言中 LinkedHashMap 这样一个常用的容器，也用到了散列表和链表两种数据结构。

那么，在这几个问题中，散列表和链表都是如何组合起来使用的，以及为什么散列表和链表会经常被放到一块使用呢？

LRU缓存淘汰算法

首先，我们来回顾一下当时是如何通过链表实现 LRU 缓存淘汰算法的。

我们需要维护一个按照访问时间从大到小有序排列的链表结构，越靠近链表尾部的结点是越早之前访问的。当要缓存某个数据时，我们从链表头开始顺序遍历链表，查找这个数据是否存在于链表中。如果没有找到，则直接将数据放到链表的尾部；如果找到了，我们就把它移动到链表的尾部。因为缓存大小有限，当缓存空间不够，需要淘汰一个数据的时候，我们就直接将链表头部的结点删除。

总结一下，一个缓存（cache）系统主要包含下面这几个操作：

• 往缓存中添加一个数据；
• 从缓存中删除一个数据；
• 在缓存中查找一个数据。

这三个操作都要涉及“查找”操作，因为查找数据需要遍历链表，所以单纯用链表实现的 LRU 缓存淘汰算法的时间复杂很高，是 O(n)。借助散列表，我们可以把 LRU 缓存淘汰算法这三个操作的时间复杂度降低为 O(1)。现在，我们就来看看它是如何做到的，具体的结构就是下面这个样子：

如上图所示，我们使用双向链表存储数据，链表中的每个结点处理存储数据（data）、前驱指针（prev）、后继指针（next）之外，还新增了一个特殊的字段 hnext。这个 hnext 有什么作用呢？

因为我们的散列表是通过链表法解决散列冲突的，所以每个结点会在两条链中。一个链是刚刚我们提到的双向链表，另一个链是散列表中的拉链。前驱和后继指针是为了将结点串在双向链表中，而hnext 指针是为了将结点串在散列表的拉链中。

了解了这个散列表和双向链表的组合存储结构之后，我们再来看，将散列表和链表两种数据结构组合使用，是如何将前面讲到的缓存的三个操作做到时间复杂度是 O(1) 的？

首先，我们来看如何查找一个数据。我们前面讲过，散列表中查找数据的时间复杂度接近 O(1)，所以通过散列表，我们可以很快地在缓存中找到一个数据。当找到数据之后，我们还需要将它移动到双向链表的尾部，这个操作所需的时间复杂度也为 O(1)。所以，查找一个数据只需要 O(1) 的时间复杂度。

其次，我们来看如何删除一个数据。我们需要找到数据所在的结点，然后将结点删除。借助散列表，我们可以在 O(1) 时间复杂度里找到要删除的结点。因为我们的链表是双向链表，双向链表可以通过前驱指针获取前驱结点，所以在双向链表中，删除结点只需要 O(1) 的时间复杂度。

最后，我们来看如何添加一个数据。我们需要先看这个数据是否已经在缓存中，散列表中查找数据的时间复杂度接近 O(1)，如果已经在其中，需要将其移动到双向链表的尾部；如果不在其中，还要看缓存有没有满。如果满了，则将双向链表头部的结点删除，然后再将数据放到链表的尾部；如果没有满，就直接将数据放到链表的尾部，在双向链表中这些都只需要 O(1) 的时间复杂度。

总结一下，这整个过程涉及的查找操作都可以通过散列表来完成。其他的操作，比如**删除头结点、链表尾部插入数据等，通过双向链表，也都可以在 O(1) 的时间复杂度内完成。**所以，这三个操作的时间复杂度都是 O(1)。至此，我们就通过散列表和双向链表的组合使用，实现了一个高效的、支持 LRU 缓存淘汰算法的缓存系统原型。

Redis 有序集合

实际上，在有序集合中，每个成员对象有两个重要的属性，**key（键值）**和 score（分值）。我们不仅会通过 score 来查找数据，还会通过 key 来查找数据。举个例子，比如用户积分排行榜有这样一个功能：我们可以通过用户的 ID 来查找积分信息，也可以通过积分区间来查找用户 ID 或者姓名信息。这里包含 ID、姓名和积分的用户信息，就是成员对象，用户 ID 就是 key，积分就是 score。

所以，如果我们细化一下 Redis 有序集合的操作，那就是下面这样：

• 添加一个成员对象；
• 按照键值来删除一个成员对象；
• 按照键值来查找一个成员对象；
• 按照分值区间查找数据，比如查找积分在 [100, 356] 之间的成员对象；
• 按照分值从小到大排序成员变量；

如果我们仅仅按照分值将成员对象组织成跳表的结构，那当按照键值来删除、查询成员对象就会很慢，解决方法与 LRU 缓存淘汰算法的解决方法类似。我们可以再按照键值构建一个散列表，这样按照 key 来删除、查找一个成员对象的时间复杂度就变成了 O(1)。同时，借助跳表结构，按照分值的操作也非常高效。

Java LinkedHashMap

如果你熟悉 Java，那你几乎天天会用到LinkedHashMap这个容器。之前讲过，HashMap 底层是通过散列表这种数据结构实现的，而 LinkedHashMap 前面比 HashMap 多了一个“Linked”，这里的“Linked”是不是指LinkedHashMap 是一个通过链表法解决散列冲突的散列表呢？

实际上，LinkedHashMap 并没有这么简单，其中的“Linked”也并不仅仅代表它是通过链表法解决散列冲突的。先来看一段代码。你觉得这段代码会以什么样的顺序打印 3，1，5，2 这几个 key 呢？

HashMap<Integer, Integer> m = new LinkedHashMap<>();
m.put(3, 11);
m.put(1, 12);
m.put(5, 23);
m.put(2, 22);

for (Map.Entry e : m.entrySet()) {
  System.out.println(e.getKey());
}

答案是，上面的代码会按照数据插入的顺序依次来打印，也就是说，打印结果的顺序就是 3，1，5，2。有没有觉得奇怪？散列表中数据是经过散列函数打乱之后无规律存储的，那这里是如何实现按照数据的插入顺序来遍历打印的呢？
实际上，LinkedHashMap 也是通过散列表和链表组合在一起实现的。实际上，它不仅支持按照插入顺序遍历数据，还支持按照访问顺序来遍历数据。举个例子，再来看看下面这段代码：

// 10是初始大小，0.75是装载因子，true是表示按照访问时间排序
HashMap<Integer, Integer> m = new LinkedHashMap<>(10, 0.75f, true);
m.put(3, 11);
m.put(1, 12);
m.put(5, 23);
m.put(2, 22);

m.put(3, 26);
m.get(5);

for (Map.Entry e : m.entrySet()) {
  System.out.println(e.getKey());
}

这段代码打印的结果是 1，2，3，5。为什么呢？

我们来具体分析一下这个代码的运行过程，每次调用 put() 函数，往 LinkedHashMap 中添加数据的时候，都会将数据添加到链表的尾部，所以，在前四个操作完成之后，链表中的数据是下面这样：

在第 8 行代码中，再次将键值为 3 的数据放入到 LinkedHashMap 的时候，会先查找这个键值是否已经有了，然后，再将已经存在的 (3,11) 删除，并且将新的 (3,26) 放到链表的尾部。所以，这个时候链表中的数据就是下面这样：

当第 9 行代码访问到 key 为 5 的数据的时候，我们将被访问到的数据移动到链表的尾部。所以，第 9 行代码之后，链表中的数据是下面这样：

所以，最后打印出来的数据是 1，2，3，5。其实，我们可以发现按照访问时间排序的 LinkedHashMap 本身就是一个支持 LRU 缓存淘汰策略的缓存系统。实际上，它们两个的实现原理也是一模一样的。

总结一下，LinkedHashMap 是通过双向链表和散列表这两种数据结构组合实现的。LinkedHashMap 中的“Linked”实际上是指的是双向链表，并非仅仅指用链表法解决散列冲突。

解答开篇：为什么散列表和链表经常一块使用？

散列表这种数据结构虽然支持非常高效的数据插入、删除、查找操作，但是**散列表中的数据都是通过散列函数打乱之后无规律存储的。也就说，它无法支持按照某种顺序快速地遍历数据。**如果希望按照顺序遍历散列表中的数据，那我们需要将散列表中的数据拷贝到数组中，然后排序，再遍历。因为散列表是动态数据结构，不停地有数据的插入、删除，所以如果采用数组结构，每当我们希望按顺序遍历散列表中的数据的时候，都需要先排序，那效率势必会很低。为了解决这个问题，我们将散列表和链表（或者跳表）结合在一起使用。

小结

一、为什么散列表和链表经常放在一起使用？
1.散列表的优点：支持高效的数据插入、删除和查找操作
2.散列表的缺点：数据都是通过散列函数打乱之后无规律存储的，也就是说，它不支持快速按照某种顺序遍历散列表中的数据
3.如何按照顺序快速遍历散列表的数据：只能将数据转移到数组，然后排序，最后再遍历数据。
4.我们知道散列表是动态的数据结构，需要频繁的插入和删除数据，如果每次顺序遍历之前都需要先转移到数组再排序，这势必会造成效率非常低下。
5.如何解决上面的问题呢：将散列表和链表（或跳表）结合起来使用。

二、散列表和链表如何组合起来使用？

1. LRU（Least Recently Used）缓存淘汰算法
   1.1.LRU缓存淘汰算法主要操作有哪些？主要包含3个操作：
   ①往缓存中添加一个数据；
   ②从缓存中删除一个数据；
   ③在缓存中查找一个数据；
   总结：上面3个都涉及到查找。
   1.2.如何用链表实现LRU缓存淘汰算法？
   ①需要维护一个按照访问时间从大到小的有序排列的链表结构。
   ②由于缓冲空间有限，当空间不足，需要淘汰一个数据时，直接删除链表头部的节点。
   ③当要缓存某个数据时，先在链表中查找这个数据。若未找到，则直接将数据放到链表的尾部。若找到，就把它移动到链表尾部。
   ④前面说了，LRU缓存的3个主要操作都涉及到查找，若单纯由链表实现，查找的时间复杂度很高为O(n)。若将链表和散列表结合使用，查找的时间复杂度会降低到O(1)。
   1.3.如何使用散列表和链表实现LRU缓存淘汰算法？
   ①使用双向链表存储数据，链表中每个节点存储数据（data）、前驱指针（prev）、后继指针（next）和hnext指针（解决散列冲突的链表指针）。
   ②散列表通过链表法解决散列冲突，所以每个节点都会在两条链中。一条链是双向链表，另一条链是散列表中的拉链。前驱和后继指针是为了将节点串在双向链表中，hnext指针是为了将节点串在散列表的拉链中。
   ③LRU缓存淘汰算法的3个主要操作如何做到时间复杂度为O(1)呢？
   首先，我们明确的一点是链表本身插入和删除一个节点的时间复杂度为O(1)，因为只需更改几个指针指向即可。接着，再来分析查找操作的时间复杂度。当要查找一个数据时，通过散列表可实现在O(1)时间复杂度找到该数据，再加上前面说的插入或删除的时间复杂度是O(1)，所以我们总操作的时间复杂度就是O(1)。
2. Redis有序集合
   2.1.什么是有序集合？
   ①在有序集合中，每个成员对象有2个重要的属性，即key（键值）和score（分值）。
   ②不仅会通过score来查找数据，还会通过key来查找数据。
   2.2.有序集合的操作有哪些？
   举个例子，比如用户积分排行榜有这样一个功能：可以通过用户ID来查找积分信息，也可以通过积分区间来查找用户ID。这里用户ID就是key，积分就是score。所以，有序集合的操作如下：
   ①添加一个对象；
   ②根据键值删除一个对象；
   ③根据键值查找一个成员对象；
   ④根据分值区间查找数据，比如查找积分在[100.356]之间的成员对象；
   ⑤按照分值从小到大排序成员变量。
   这时可以按照分值将成员对象组织成跳表结构，并且按照键值构建一个散列表。那么上面的所有操作都非常高效。
3. Java LinkedHashMap
   3.1 LinkedHashMap 是通过双向链表和散列表这两种数据结构组合实现的。LinkedHashMap 中的“Linked”实际上是指的是双向链表，并非仅仅指用链表法解决散列冲突。
   3.2 和LRU缓存淘汰策略的实现一模一样。支持按照插入顺序遍历数据，也支持按照访问顺序遍历数据。

思考题

1. 前面讲的几个散列表和链表结合使用的例子里，我们用的都是双向链表。如果把双向链表改成单链表，还能否正常工作呢？为什么？
2. 假设猎聘网有 10 万名猎头，每个猎头都可以通过做任务（比如发布职位）来积累积分，然后通过积分来下载简历。如果你是猎聘网的一名工程师，如何在内存中存储这 10 万个猎头的 ID 和积分信息，让它能够支持这样几个操作：
   （1）根据猎头的 ID 快速查找、删除、更新这个猎头的积分信息；
   （2）查找积分在某个区间的猎头 ID 列表；
   （3）查找按照积分从小到大排名在第 x 位到第 y 位之间的猎头 ID 列表。

参考

《数据结构与算法之美》
王争
前Google工程师