链表:如何实现LRU缓存淘汰算法

04 链表(上): 如何实现LRU缓存淘汰算法?

一、什么是链表？

1. 和数组一样，链表也是一种线性表。
2. 从内存结构来看，链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。
3. 链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针Next。

二、为什么使用链表？即链表的特点

• 插入、删除数据效率高O(1)级别（只需更改指针指向即可），随机访问效率低O(n)级别（需要从链头至链尾进行遍历）。

• 和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储后继指针。

  

三、常用链表：单链表、循环链表和双向链表

• 单链表
  1）每个节点只包含一个指针，即后继指针。
  2）单链表有两个特殊的节点，即首节点和尾节点。为什么特殊？用首节点地址表示整条链表，尾节点的后继指针指向空地址null。
  3）性能特点：插入和删除节点的时间复杂度为O（1），查找的时间复杂度为O(n)。
• 循环链表
  1）除了尾节点的后继指针指向首节点的地址外均与单链表一致。
  2）适用于存储有循环特点的数据，比如约瑟夫问题。
• 双向链表
  1）节点除了存储数据外，还有两个指针分别指向前一个节点地址（前驱指针prev）和下一个节点地址（后继指针next）。
  2）首节点的前驱指针prev和尾节点的后继指针均指向空地址。
  3）性能特点：
  和单链表相比，存储相同的数据，需要消耗更多的存储空间。
  插入、删除操作比单链表效率更高O(1)级别。以删除操作为例，删除操作分为2种情况：给定数据值删除对应节点和给定节点地址删除节点。对于前一种情况，单链表和双向链表都需要从头到尾进行遍历从而找到对应节点进行删除，时间复杂度为O(n)。对于第二种情况，要进行删除操作必须找到前驱节点，单链表需要从头到尾进行遍历直到p->next = q，时间复杂度为O(n)，而双向链表可以直接找到前驱节点，时间复杂度为O(1)。
  对于一个有序链表，双向链表的按值查询效率要比单链表高一些。因为我们可以记录上次查找的位置p，每一次查询时，根据要查找的值与p的大小关系，决定是往前还是往后查找，所以平均只需要查找一半的数据。
• 双向循环链表：首节点的前驱指针指向尾节点，尾节点的后继指针指向首节点。

四、选择数组还是链表？

• 插入、删除和随机访问的时间复杂度
  数组：插入、删除的时间复杂度是O(n)，随机访问的时间复杂度是O(1)。
  链表：插入、删除的时间复杂度是O(1)，随机访问的时间复杂端是O(n)。
• 数组缺点
  1）若申请内存空间很大，比如100M，但若内存空间没有100M的连续空间时，则会申请失败，尽管内存可用空间超过100M。
  2）大小固定，若存储空间不足，需进行扩容，一旦扩容就要进行数据复制，而这时非常费时的。
• 链表缺点
  1）内存空间消耗更大，因为需要额外的空间存储指针信息。
  2）对链表进行频繁的插入和删除操作，会导致频繁的内存申请和释放，容易造成内存碎片，如果是Java语言，还可能会造成频繁的GC（自动垃圾回收器）操作。
• 如何选择？
  数组简单易用，在实现上使用连续的内存空间，可以借助CPU的缓冲机制预读数组中的数据，所以访问效率更高，而链表在内存中并不是连续存储，所以对CPU缓存不友好，没办法预读。
  如果代码对内存的使用非常苛刻，那数组就更适合。

五、应用

如何分别用链表和数组实现LRU缓冲淘汰策略？

1. 什么是缓存？
   缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非广泛的应用，比如常见的CPU缓存、数据库缓存、浏览器缓存等等。

2. 为什么使用缓存？即缓存的特点
   缓存的大小是有限的，当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留？就需要用到缓存淘汰策略。

3. 什么是缓存淘汰策略？
   指的是当缓存被用满时清理数据的优先顺序。

4. 有哪些缓存淘汰策略？
   常见的3种包括先进先出策略FIFO（First In，First Out）、最少使用策略LFU（Least Frequently Used）、最近最少使用策略LRU（Least Recently Used）。

5. 链表实现LRU缓存淘汰策略
   当访问的数据没有存储在缓存的链表中时，直接将数据插入链表表头，时间复杂度为O(1)；当访问的数据存在于存储的链表中时，将该数据对应的节点，插入到链表表头,时间复杂度为O(n)。如果缓存被占满，则从链表尾部的数据开始清理，时间复杂度为O(1)。

6. 数组实现LRU缓存淘汰策略

   方式一：首位置保存最新访问数据，末尾位置优先清理
   当访问的数据未存在于缓存的数组中时，直接将数据插入数组第一个元素位置，此时数组所有元素需要向后移动1个位置，时间复杂度为O(n)；当访问的数据存在于缓存的数组中时，查找到数据并将其插入数组的第一个位置，此时亦需移动数组元素，时间复杂度为O(n)。缓存用满时，则清理掉末尾的数据，且剩余数组元素需整体后移一位，时间复杂度为O(n)。

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

六、设计思想

时空替换思想：“用空间换时间” 与 “用时间换空间”
当内存空间充足的时候，如果我们更加追求代码的执行速度，我们就可以选择空间复杂度相对较高，时间复杂度小相对较低的算法和数据结构，缓存就是空间换时间的例子。如果内存比较紧缺，比如代码跑在手机或者单片机上，这时，就要反过来用时间换空间的思路。

七、课后习题

如何判断一个字符串是否是回文字符串的问题，我想你应该听过，我们今天的题目就是基于这个问题的改造版本。如果字符串是通过单链表来存储的，那该如何来判断是一个回文串呢？你有什么好的解决思路呢？相应的时间空间复杂度又是多少呢？

方法一：半栈法

1. 用快慢两个指针遍历，同时用栈copy慢指针指向的data。
2. 完成后，慢指针指向中间节点，耗时为N/2.
3. 最后用pop栈中的data和慢指针指向的data比较，耗时也是N/2.
   所以时间复杂度为：Ｏ(N)，空间复杂度因栈额外存储了一半的data，故为O(N/2)

方法二：全栈法

1. 全部遍历，data压栈，额外空间消耗N
2. 再次全部遍历取data，同时pop栈取data, 二者比较，时间消耗2N。
   所以时间复杂度为O(3N)，空间复杂度为O(N)。
   该法算法最简单，但复杂度高。可以用栈存储节点指针，而非data来改进。

方法三：硬干法

1. 一个指针从头取data，另一个指针遍历到底取data，比较二者，删除尾部节点，重复１。

   时间复杂度高达 O(N^2)，空间复杂度却最低Ｏ(1)。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
  public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) {
      return true;
    }

    ListNode prev = null;
    ListNode slow = head;
    ListNode fast = head;

    while (fast != null && fast.next != null) {
      fast = fast.next.next;
      ListNode next = slow.next;
      slow.next = prev;
      prev = slow;
      slow = next;
    }

    if (fast != null) {
      slow = slow.next;
    }

    while (slow != null) {
      if (slow.val != prev.val) {
        return false;
      }
      slow = slow.next;
      prev = prev.next;
    }

    return true;
  }
}

https://leetcode.wang/leetcode-234-Palindrome-Linked-List.html

04 链表(下): 如何实现LRU缓存淘汰算法?

一、理解指针或引用的含义

1. 含义：指针是一个变量，该变量中存的是其它变量的地址。将某个变量（对象）赋值给指针（引用），实际上就是就是将这个变量（对象）的地址赋值给指针（引用）。
2. 示例：
   p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。
   p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。

二、警惕指针丢失和内存泄漏（单链表）

在插入和删除结点时，要注意先持有后面的结点再操作，否者一旦后面结点的前继指针被断开，就无法再访 问，导致内存泄漏。

1. 插入节点
   在节点a和节点b之间插入节点x，b是a的下一节点，，p指针指向节点a，则造成指针丢失和内存泄漏的代码：p—>next = x;x—>next = p—>next; 显然这会导致x节点的后继指针指向自身。
   正确的写法是2句代码交换顺序，即：x—>next = p—>next; p—>next = x;
2. 删除节点
   在节点a和节点b之间删除节点b，b是a的下一节点，p指针指向节点a：p—>next = p—>next—>next;

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

链表的插入、删除操作，需要对插入第一个结点和删除最后一个节点做特殊处理。利用哨兵对象可以不用边界判断，链表的哨兵对象是只存指针不存数据的头结点。

1. 什么是“哨兵”？
   链表中的“哨兵”节点是解决边界问题的，不参与业务逻辑。如果我们引入“哨兵”节点，则不管链表是否为空，head指针都会指向这个“哨兵”节点。我们把这种有“哨兵”节点的链表称为带头链表，相反，没有“哨兵”节点的链表就称为不带头链表。

2. 未引入“哨兵”的情况
   如果在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;}
   

   从上面的情况可以看出，针对链表的插入、删除操作，需要对插入第一个节点和删除最后一个节点的情况进行特殊处理。这样代码就会显得很繁琐，所以引入“哨兵”节点来解决这个问题。

3. 引入“哨兵”的情况
   “哨兵”节点不存储数据，无论链表是否为空，head指针都会指向它，作为链表的头结点始终存在。这样，插入第一个节点和插入其他节点，删除最后一个节点和删除其他节点都可以统一为相同的代码实现逻辑了。

四、重点留意边界条件处理

经常用来检查链表是否正确的边界4个边界条件：

1. 如果链表为空时
2. 如果链表只包含一个节点时
3. 如果链表只包含两个节点时
4. 代码逻辑在处理头尾节点时

五、举例画图，辅助思考

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

六、多写多练，没有捷径

5个常见的链表操作：

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

练习题LeetCode对应编号：206，141，21，19，876

哨兵代码优势: 代码2为什么比代码1性能更优? 为什么代码2少了一个比较?

原因如下,首先要明确作者举两个代码例子的目的是为了说明"哨兵"的优势.
我们先分析没有哨兵的代码1,逻辑很简单,在遍历数组的时候,挨个比较每一个元素是否等于key,另外我们要还判断循环条件i是否小于n,如果相等了,那么就退出循环遍历,所以针对每一个元素判断都进行了2次比较.
代码2,一开始就把数组中最后一个元素修改成了目标key,while一次循环中,循环条件仅仅判断当前数组元素是否等于key,对于跳出循环的条件是省略的,为什么呢?因为前面说了,数组最后一个元素改成了key,最后肯定会在数组中找到key,也就是定会跳出. 于是最后我们只关注i是不是n-1就可以了,是n-1代表"原始整个数组"元素中的确没有key.