数据结构与算法之美---CH06+CH07---链表

0. 开篇问题

  缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。 缓存的大小有限，当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留？这就需要缓存淘汰策略来决定。常见的策略有三种：先进先出策略 FIFO(First In，First Out)、最少使用策略 LFU(Least Frequently Used)、最近最少使用策略 LRU(Least Recently Used)。
  那么如何用链表实现缓存淘汰策略？

1. 什么是链表

1. 链表和数组一样，是一种线性表结构。
2. 链表不要求连续内存空间来存储，它通过“指针”将一组零散的内存块串联起使用

链表和数组的内存分布如下图所示：

2. 常见链表结构

2.1 单链表

单链表的结构如下图所示，

1. 每个节点除了存储数据外，还一个后继指针，指向下一个节点。
2. 单链表有两个特殊的节点，即首节点和尾节点。首节点地记录链表的基地址，可以用来遍历整个链表，尾节点的后继指针指向空地址null。
3. 性能特点：插入和删除节点的时间复杂度为O(1)，查找的时间复杂度为O(n)。

插入和删除节点的操作如下图所示，

2.2 循环链表

循环链表是一种特殊的单链表，其结构如下图所示，

1. 循环链表的尾结点指针指向链表的头结点，其余和单链表一致。
2. 循环链表优点是从链尾到链头的遍历比较方便，适用于存储有循环特点的数据，比如约瑟夫问题。
3. 性能特点：同单链表

2.3 双向链表

  实际软件开发中，更加常用的是双向链表。单链表只有一个方向，每个节点只存储后继节点的指针，而双向链表，顾名思义支持两个方向，每个结点不止有一个后继指针 next 指向后面的结点，还有一个前驱指针 prev 指向前面的结点。
其结构如下图所示：

1. 节点除了存储数据外，还有两个指针分别指向前一个节点地址（前驱指针prev）和下一个节点地址（后继指针next）。
2. 首节点的前驱指针prev和尾节点的后继指针均指向空地址NULL。
3. 性能特点：
   (1)由于prev的存在，存储相同数据，比单链表占用更多内存空间。
   (2) 插入，删除操作比单链表效率更高。
     这点要详细说一下，从时间复杂度来看都是O(1)，为什么双向链表效率更高？
     以删除为例，从链表中删除一个数据无外乎这两种情况：a. 删除结点中“值等于某个给定值”的结点；b. 删除给定指针指向的结点。
   情况一：单链表和双向链表都需要从头到尾进行遍历从而找到对应节点进行删除，时间复杂度为O(n)。
   情况二：要进行删除操作必须找到前驱节点，单链表需要从头到尾进行遍历直到p->next = q，时间复杂度为O(n)，而双向链表可以直接找到前驱节点，时间复杂度为O(1)。
     插入同理。
   (3) 有序链表情况下，双向链表查找比单链表更加高效。
   因为我们可以记录上次查找的位置p，每一次查询时，根据要查找的值与p的大小关系，决定是往前还是往后查找，所以平均只需要查找一半的数据。

以空间换时间的思想，在这里闪耀。

2.4 双向循环链表

顾名思义，如下图所示：

3. 数组和链表的抉择

3.1 优缺点对比

1. 链表插入和删除的事件复杂度为O(1)，随机访问时间复杂度为O(n)，与数组正好相反。

这里没提到查找，数组那一节已经提到过，查找的事件复杂度为O(n)和链表一致。
2. 数组缺点
a. 对内存空间要求苛刻，要求连续。
b. 大小固定，若存储空间不足，需进行扩容，一旦扩容就要手动申请更大内存，进行数据复制。
c. 不支持动态扩容，而链表支持动态扩容

3. 链表缺点
   a. 内存空间消耗更大，需要额外的空间存储指针。
   b. 对链表进行频繁的插入和删除操作，会导致频繁的内存申请和释放，容易造成内存碎片.如果是Java语言，可能会造成频繁GC操作。
   c. 链表支持动态扩容，这是一个特点，但不是一个绝对的优点，也会存在内存拷贝的问题。因此链表申请的时候，最好预估一下大小，这样避免触发动态扩容。

3.2 如何选择

1. 数组简单易用，在实现上使用连续的内存空间，可以借助CPU的缓冲机制预读数组中的数据，所以访问效率更高，而链表在内存中并不是连续存储，所以对CPU缓存不友好，没办法预读。
2. 在开发过程中，根据存储数据的常用操作，选择链表或者数组。

4. 写出bug free的链表代码的技巧

4.1 理解指针或引用的含义

对于指针的理解，你只需要记住下面这句话就可以了：

1. 将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针。
2. 反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。

示例：
  p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。
  p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。
  掌握指针和引用就能够轻松看懂链表了。

4.2 警惕指针丢失和内存泄漏

插入操作如下图所示：

如果代码写成如下方式：

p->next = x;  // 将 p 的 next 指针指向 x 结点；
x->next = p->next;  // 将 x 的结点的 next 指针指向 b 结点，但实际上指向了x

  如此，导致链表断了，b后的所有节点无法访问，内存出现泄漏。
  删除节点时，要手动释放内存，避免泄漏，java程序员可以不用过滤。

4.3 利用“哨兵”简化实现难度

4.3.1 特殊节点处理繁琐

插入操作：
如果在p节点后插入一个节点，只需2行代码即可：

new_node—>next = p—>next;
p—>next = new_node;

但若向空链表中插入一个节点，则需特殊处理如下：

if(head == null){
	head = new_node;
}

删除操作：
如果要删除节点p的后继节点，只需1行代码即可：

p—>next = p—>next—>next;

但若是删除链表的最后一个节点（链表中只剩下这个节点），则代码如下：

if(head—>next == null){
	head = null;
}

4.3.2 应用“哨兵”简化处理

  链表中的“哨兵”节点是解决边界问题的，不参与业务逻辑。如果我们引入“哨兵”节点，则不管链表是否为空，head指针都会指向这个“哨兵”节点。我们把这种有“哨兵”节点的链表称为带头链表，相反，没有“哨兵”节点的链表就称为不带头链表。
  “哨兵”节点不存储数据，无论链表是否为空，head指针都会指向它，作为链表的头结点始终存在。这样，插入第一个节点和插入其他节点，删除最后一个节点和删除其他节点都可以统一为相同的代码实现逻辑了。

4.4 重点留意边界条件处理

1.如果链表为空时，代码是否能正常工作？
2.如果链表只包含一个节点时，代码是否能正常工作？
3.如果链表只包含两个节点时，代码是否能正常工作？
4.代码逻辑在处理头尾节点时是否能正常工作？

4.5 举例画图，辅助思考

核心思想：释放脑容量，留更多的给逻辑思考，这样就会感觉到思路清晰很多。

4.6 多写多练，没有捷径

代码是写出来的，不是说出来的。
5个常见的链表操作：

1. 单链表反转
2. 链表中环的检测
3. 两个有序链表合并
4. 删除链表倒数第n个节点
5. 求链表的中间节点
   leetcode: 206 141 21 19 876

5. 解开篇答

  实现思路：维护一个有序单链表，越靠近链表尾部的结点是越早之前访问的。当有一个新的数据被访问时，我们从链表头开始顺序遍历链表。

1. 如果此数据之前已经被缓存在链表中了，我们遍历得到这个数据对应的结点，并将其从原来的位置删除，然后再插入到链表的头部。
2. 如果此数据没有在缓存链表中，又可以分为两种情况：
   a. 如果此时缓存未满，则将此结点直接插入到链表的头部；
   b. 如果此时缓存已满，则链表尾结点删除，将新的数据结点插入链表的头部。

  复杂度分析：不管缓存有没有满，我们都需要遍历一遍链表，所以这种基于链表的实现思路，缓存访问的时间复杂度为 O(n)。
  实际上，我们可以继续优化这个实现思路，比如引入散列表（Hash table）来记录每个数据的位置，将缓存访问的时间复杂度降到 O(1)。

6. 课后思考

6.1 数组实现LRU策略？

   方式一：首位置保存最新访问数据，末尾位置优先清理
当访问的数据未存在于缓存的数组中时，直接将数据插入数组第一个元素位置，此时数组所有元素需要向后移动1个位置，时间复杂度为O(n)；当访问的数据存在于缓存的数组中时，查找到数据并将其插入数组的第一个位置，此时亦需移动数组元素，时间复杂度为O(n)。缓存用满时，则清理掉末尾的数据，时间复杂度为O(1)。
  方式二：首位置优先清理，末尾位置保存最新访问数据
当访问的数据未存在于缓存的数组中时，直接将数据添加进数组作为当前最有一个元素时间复杂度为O(1)；当访问的数据存在于缓存的数组中时，查找到数据并将其插入当前数组最后一个元素的位置，此时亦需移动数组元素，时间复杂度为O(n)。缓存用满时，则清理掉数组首位置的元素，且剩余数组元素需整体前移一位，时间复杂度为O(n)。（优化：清理的时候可以考虑一次性清理一定数量，从而降低清理次数，提高性能。）

6.2 单链表存储字符串，判断是否是回文串？

  使用快慢两个指针找到链表中点，慢指针每次前进一步，快指针每次前进两步。在慢指针前进的过程中，同时修改其 next 指针，使得链表前半部分反序。最后比较中点两侧的链表是否相等。
时间复杂度：O(n)
空间复杂度：O(1)