散列表（下）：为什么散列表和链表经常会一起使用？

散列表和链表经常会被放在一起使用。

在链表那一节，学到了如何用链表来实现 LRU 缓存淘汰算法，但是链表实现的缓存淘汰算法的时间复杂度是 ○(n)，通过散列表可以将这个时间复杂度降到 ○(1)。

在跳表那一节，学到了 Redis 的有序集合是使用跳表来实现的，跳表可以看作一种改进版的链表。Redis 有序集合不仅用到了跳表，还用到了散列表。

LinkedHashMap 也用到了散列表和链表两种数据结构。

那么散列表和链表都是如何组合起来使用的，以及为什么散列表和链表会经常放到一起使用呢？

一、LRU 缓存淘汰算法

在链表那一节中，了解到可以借助散列表，把 LRU 淘汰算法的时间复杂度降低为 ○(1)。现在来看看它是如何做到的。

链表实现LRU缓存算法

所以一个缓冲（cache）系统主要包含下面这几个操作：

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

这三个操作，都会涉及到 “查找” 操作，如果单纯地采用链表的话，时间复杂度只能是 ○(n)，如果将散列表和链表两种数据结构组合使用，可以将这三个操作的时间复杂度都降低到 ○(1)。具体结构如下：

散列表与双向链表实现LRU缓存的结构

注意，双向链表中，除了存储的数据data、前驱指针prev、后继指针next之外还新增了一个特殊字段 hnext，这个henxt用来干什么呢？

这个散列表是通过链表法解决散列冲突的。前驱和后继指针是为了将结点串在双向链表中，hnext 指针是为了将结点串在散列表的拉链中。

这个拉链是用来干什么的？

那么缓存的三个操作，是如何做到时间复杂度是 ○(1) 的？
如何查找一个数据
散列表中查找数据的时间复杂度接近 ○(1)，所以通过散列表，我们可以很快地在缓存中找到一个数据，当找到数据之后，我们还需要将它移到双向链表的尾部。

如何删除一个数据
需要找到数据所在的结点，然后将结点删除。借助散列表，我们可以在 ○(1) 时间复杂度里找到要删除的结点。因为使用的双向链表，可以通过前驱指针在 ○(1) 时间复杂度的情况下获取到前驱结点，所以删除节点只需要 ○(1) 的时间复杂度。

如何添加一个数据
需要先看这个数据是否已经在缓存中，如果已经在其中，需要将其移动到双向链表的尾部；如果不在其中，还要看缓存有没有满。如果满了，则将双向链表头部的结点删除，然后再将数据放到链表的尾部；如果没有满，就直接将数据放到链表的尾部。

image

二、Redis 有序集合

在跳表那一节，在有序集合中，每个成员对象有两个重要的属性：key 键值 score 分值。不仅会通过 score 来查找数据，还会通过 key 来查找数据。

例子：
比如用户积分排行榜有这样一个功能：可以通过用户的 ID（ID 就是key） 来查找积分信息，也可以通过积分区间来查找用户 ID 或者 姓名信息。这里包含 ID、姓名和积分的用户信息，就是成员对象，用户 ID 就是 key，积分就是 score（积分只是在当前这个积分榜业务场景里的一个变量）。

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

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

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

实际上，Redis 有序集合的操作还有另一类，也就是查找成员对象的排名（Rank）或者根据排名区间查找成员对象。这个功能单纯用刚刚将的这种组合结构就无法高效实现了。后面会学到如何实现。

三、Java LinkedHashMap

前面了解到，HashMap 底层是通过散列表这种数据结构实现的。而 LinkedHashMap 前面比 HashMap 多了个 “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());
}

首先我们看一下，下面代码的输出是什么

HashMap<Integer,Integer> m = new HashMap<>();
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());
}

image

但是，如果使用的是 LinkedHashMap ，那么实际上打印出的是下图：

image

为什么 HashMap 输出的就是无需的，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());
}

image

分析
每次调用 put() 函数，往 LinkedHashMap 中添加数据的时候，都会将数据添加到链表尾部，所以在前四个操作完成之后，链表中的数据是下面这样的：

image

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

image

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

image

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

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

四、解答开篇

为什么散列表和链表经常一起使用？

散列表这种数据结构虽然支持非常高效的数据插入、删除、查找操作，但是散列表中的数据都是通过散列函数打乱之后无规律存储的（HashMap 无规律）。也就是说，它无法支持按照某种顺序快速地遍历数据。如果希望按照顺序遍历散列表中的数据，那我们需要将散列表中的数据拷贝到数组中，然后排序，再遍历。

因为散列表是动态数据结构，不停地有数据的插入、删除，所以当我们希望按顺序遍历散列表中的数据的时候，都需要先排序，那效率会很低，为了解决这个问题，将散列表和链表（或者跳表）结合在一起使用。