散列表和链表都是如何组合起来使用的?
为什么散列表和链表会经常放到一块使用?

LRU 缓存淘汰算法

借助散列表,我们可以把 LRU 缓存淘汰算法的时间复杂度降低为 O(1)。
实现过程:
我们需要维护一个按照访问时间从大到小有序排列的链表结构。因为缓存大小有限,当缓存空间不够,需要淘汰一个数据的时候,我们就直接将链表头部的结点删除。当要缓存某个数据的时候,先在链表中查找这个数据。如果没有找到,则直接将数据放到链表的尾部;如果找到了,我们就把它移动到链表的尾部。因为查找数据需要遍历链表,所以单纯用链表实现的 LRU 缓存淘汰算法的时间复杂很高,是 O(n)。

一个Cache主要包含以下三个操作:

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

以上三个操作都涉及都会涉及“查询操作”。如果单纯地采用链表的话,时间复杂度只能是 O(n)。如果我们将散列表和链表两种数据结构组合使用,可以将这三个操作的时间复杂度都降低到 O(1)。具体的结构就是下面这个样子:
image.png
因为我们的散列表是通过链表法解决散列冲突的,所以每个结点会在两条链中。一个链是刚刚我们提到的双向链表,另一个链是散列表中的拉链。前驱和后继指针是为了将结点串在双向链表中,hnext 指针是为了将结点串在散列表的拉链中。

Redis 有序集合

在有序集合中,每个成员对象有两个重要的属性,key(键值)和 score(分值)。
我们不仅会通过 score 来查找数据,还会通过 key 来查找数据。举个例子,比如用户积分排行榜有这样一个功能:我们可以通过用户的 ID 来查找积分信息,也可以通过积分区间来查找用户 ID 或者姓名信息。这里包含 ID、姓名和积分的用户信息,就是成员对象,用户 ID 就是 key,积分就是 score。所以,如果我们细化一下 Redis 有序集合的操作,那就是下面这样:

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

如果我们仅仅按照分值将成员对象组织成跳表的结构,那按照键值来删除、查询成员对象就会很慢,解决方法与 LRU 缓存淘汰算法的解决方法类似。我们可以再按照键值构建一个散列表,这样按照 key 来删除、查找一个成员对象的时间复杂度就变成了 O(1)。同时,借助跳表结构,其他操作也非常高效。
实际上,Redis 有序集合的操作还有另外一类,也就是查找成员对象的排名(Rank)或者根据排名区间查找成员对象。这个功能单纯用刚刚讲的这种组合结构就无法高效实现了。

Java LinkedHashMap

HashMap 底层是通过散列表这种数据结构实现的。而 LinkedHashMap 前面比 HashMap 多了一个“Linked”,这里的“Linked”是不是说,LinkedHashMap 是一个通过链表法解决散列冲突的散列表呢?
实际上,LinkedHashMap 并没有这么简单,其中的“Linked”也并不仅仅代表它是通过链表法解决散列冲突的。关于这一点,在我是初学者的时候,也误解了很久。
我们先来看一段代码。你觉得这段代码会以什么样的顺序打印 3,1,5,2 这几个 key 呢?原因又是什么呢?

  1. HashMap<Integer, Integer> m = new LinkedHashMap<>();
  2. m.put(3, 11);
  3. m.put(1, 12);
  4. m.put(5, 23);
  5. m.put(2, 22);
  6. for (Map.Entry e : m.entrySet()) {
  7. System.out.println(e.getKey());
  8. }

打印的顺序就是 3,1,5,2。
你可能已经猜到了,LinkedHashMap 也是通过散列表和链表组合在一起实现的。实际上,它不仅支持按照插入顺序遍历数据,还支持按照访问顺序来遍历数据。你可以看下面这段代码:

  1. // 10是初始大小,0.75是装载因子,true是表示按照访问时间排序
  2. HashMap<Integer, Integer> m = new LinkedHashMap<>(10, 0.75f, true);
  3. m.put(3, 11);
  4. m.put(1, 12);
  5. m.put(5, 23);
  6. m.put(2, 22);
  7. m.put(3, 26);
  8. m.get(5);
  9. for (Map.Entry e : m.entrySet()) {
  10. System.out.println(e.getKey());
  11. }

打印的结果是 1,2,3,5。

具体分析一下,为什么这段代码会按照这样顺序来打印。
每次调用 put() 函数,往 LinkedHashMap 中添加数据的时候,都会将数据添加到链表的尾部,所以,在前四个操作完成之后,链表中的数据是下面这样:
image.png
在第 8 行代码中,再次将键值为 3 的数据放入到 LinkedHashMap 的时候,会先查找这个键值是否已经有了,然后,再将已经存在的 (3,11) 删除,并且将新的 (3,26) 放到链表的尾部。所以,这个时候链表中的数据就是下面这样:
image.png
当第 9 行代码访问到 key 为 5 的数据的时候,我们将被访问到的数据移动到链表的尾部。所以,第 9 行代码之后,链表中的数据是下面这样:
image.png
所以,最后打印出来的数据是 1,2,3,5。从上面的分析,你有没有发现,按照访问时间排序的 LinkedHashMap 本身就是一个支持 LRU 缓存淘汰策略的缓存系统?实际上,它们两个的实现原理也是一模一样的。我也就不再啰嗦了。

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

解答开篇 & 内容小结

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

课后思考

1、今天讲的几个散列表和链表结合使用的例子里,我们用的都是双向链表。如果把双向链表改成单链表,还能否正常工作呢?为什么呢?
2、假设猎聘网有 10 万名猎头,每个猎头都可以通过做任务(比如发布职位)来积累积分,然后通过积分来下载简历。假设你是猎聘网的一名工程师,如何在内存中存储这 10 万个猎头 ID 和积分信息,让它能够支持这样几个操作:

  • 根据猎头的 ID 快速查找、删除、更新这个猎头的积分信息;
  • 查找积分在某个区间的猎头 ID 列表;
  • 查找按照积分从小到大排名在第 x 位到第 y 位之间的猎头 ID 列表。

1.可以通过单链表和散列表实现,但是删除和添加的时间复杂度就变成了O(n),因为需要遍历一次链表将前驱节点找到,再进行删除。
2.猎头问题:每个猎头对象由node构成(pre,next,hnext,data)将id作为键值建立类似hashmap的结构来存放猎头的对象,同时再将每个节点使用双向链表按照积分大小(快排排序)链接起来。根据id查找、删除、添加时间复杂度为O(1),查找排名的时间复杂度为O(n),如果想提高查找排名的时间复杂度,可以再和跳表结合一块,根据积分建立索引,查找排名的时间复杂度将提升为O(logn)

散列表实现第一个功能。
既然是区间那么是需要使用到跳表的这一特性,能够查询某一区间。
第三个积分是未知的。所以,可以使用跳表的最底下的一层进行第x位到第y位之间的猎头ID列表。

因为后面两个问题都是按照积分来确定位置的,所以跳表一开始是就可以通过积分的大小来进行实现。