数据结构与算法的学习（每周更新）

数据结构与算法的学习（每周更新）

来自各路大佬的笔记，我点出我需要的部分;

本篇是labuladong

一、数据结构的存储方式

数据结构的存储方式只有两种：数组（顺序存储）和链表（链式存储） 。

我们分析问题，一定要有递归的思想，自顶向下，从抽象到具体。因为那些多样化的数据结构，究其源头，都是在链表或者数组上的特殊操作，API 不同而已。

比如说「队列」、「栈」这两种数据结构既可以使用链表也可以使用数组实现。用数组实现，就要处理扩容缩容的问题；用链表实现，没有这个问题，但需要更多的内存空间存储节点指针。

「图」的两种表示方法，邻接表就是链表，邻接矩阵就是二维数组。邻接矩阵判断连通性迅速，并可以进行矩阵运算解决一些问题，但是如果图比较稀疏的话很耗费空间。邻接表比较节省空间，但是很多操作的效率上肯定比不过邻接矩阵。

「散列表」就是通过散列函数把键映射到一个大数组里。而且对于解决散列冲突的方法，拉链法需要链表特性，操作简单，但需要额外的空间存储指针；线性探查法就需要数组特性，以便连续寻址，不需要指针的存储空间，但操作稍微复杂些。

「树」，用数组实现就是「堆」，因为「堆」是一个完全二叉树，用数组存储不需要节点指针，操作也比较简单；用链表实现就是很常见的那种「树」，因为不一定是完全二叉树，所以不适合用数组存储。为此，在这种链表「树」结构之上，又衍生出各种巧妙的设计，比如二叉搜索树、AVL 树、红黑树、区间树、B 树等等，以应对不同的问题。

了解 Redis 数据库的朋友可能也知道，Redis 提供列表、字符串、集合等等几种常用数据结构，但是对于每种数据结构，底层的存储方式都至少有两种，以便于根据存储数据的实际情况使用合适的存储方式。

数据结构种类很多，甚至你也可以发明自己的数据结构，但是底层存储无非数组或者链表，二者的优缺点如下：

数组由于是紧凑连续存储,可以随机访问，通过索引快速找到对应元素，而且相对节约存储空间。但正因为连续存储，内存空间必须一次性分配够，所以说数组如果要扩容，需要重新分配一块更大的空间，再把数据全部复制过去，时间复杂度 O(N)；而且你如果想在数组中间进行插入和删除，每次必须搬移后面的所有数据以保持连续，时间复杂度 O(N)。

链表因为元素不连续，而是靠指针指向下一个元素的位置，所以不存在数组的扩容问题；如果知道某一元素的前驱和后驱，操作指针即可删除该元素或者插入新元素，时间复杂度 O(1)。但是正因为存储空间不连续，你无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

#二、数据结构的基本操作

对于任何数据结构，其基本操作无非遍历 + 访问，再具体一点就是：增删查改。

数据结构种类很多，但它们存在的目的都是在不同的应用场景，尽可能高效地增删查改。话说这不就是数据结构的使命么？

如何遍历 + 访问？我们仍然从最高层来看，各种数据结构的遍历 + 访问无非两种形式：线性的和非线性的。

线性就是 for/while 迭代为代表，非线性就是递归为代表。再具体一步，无非以下几种框架：

数组遍历框架，典型的线性迭代结构：

class ListNode{
public:
    int val;
    ListNode* next;
    ListNode(int x) : val(x),next(nullptr){}
};
//构建链表
void traverse(ListNode* head) {
    for (ListNode* p = head; p != nullptr; p = p->next) {
        // 迭代访问 p->val
    }
}
void traverse(ListNode* head) {
    // 递归访问 head->val
    traverse(head->next);
}
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x),left(nullptr),right(nullptr){}
};
//构建二叉树
void traverse(TreeNode* root){
    traverse(root->left);
    traverse(root->right);
}
//递归遍历

二叉树框架可以扩展为 N 叉树的遍历框架：

void traverse(TreeNode* root){
    for(TreeNode* child : root -> children)
        traverse(child);
}

​N​ 叉树的遍历又可以扩展为图的遍历，因为图就是好几 N​ 叉棵树的结合体。你说图是可能出现环的？这个很好办，用个布尔数组 visited​ 做标记就行了，这里就不写代码了。

所谓框架，就是套路。不管增删查改，这些代码都是永远无法脱离的结构，你可以把这个结构作为大纲，根据具体问题在框架上添加代码就行了，下面会具体举例。

我建议的刷题顺序是：

1、先学习像数组、链表这种基本数据结构的常用算法，比如单链表翻转，前缀和数组，二分搜索等。

因为这些算法属于会者不难难者不会的类型，难度不大，学习它们不会花费太多时间。而且这些小而美的算法经常让你大呼精妙，能够有效培养你对算法的兴趣。

2、学会基础算法之后，不要急着上来就刷回溯算法、动态规划这类笔试常考题，而应该先刷二叉树，先刷二叉树，先刷二叉树，重要的事情说三遍。

跟着我的博客有算法的刷题进度

数组/单链表系列算法

单链表常考的技巧就是双指针，后文 单链表六大技巧 全给你总结好了，这些技巧就是会者不难，难者不会。

比如判断单链表是否成环，拍脑袋的暴力解是什么？就是用一个 HashSet​ 之类的数据结构来缓存走过的节点，遇到重复的就说明有环对吧。但我们用快慢指针可以避免使用额外的空间，这就是聪明地穷举嘛。

当然，对于找链表中点这种问题，使用双指针技巧只是显示你学过这个技巧，和遍历两次链表的常规解法从时间空间复杂度的角度来说都是差不多的。

数组常用的技巧有很大一部分还是双指针相关的技巧，说白了是教你如何聪明地进行穷举。

首先说二分搜索技巧，可以归为两端向中心的双指针。如果让你在数组中搜索元素，一个 for 循环穷举肯定能搞定对吧，但如果数组是有序的，二分搜索不就是一种更聪明的搜索方式么。

后文 二分搜索框架详解 给你总结了二分搜索代码模板，保证不会出现搜索边界的问题。后文 二分搜索算法运用 给你总结了二分搜索相关题目的共性以及如何将二分搜索思想运用到实际算法中。

类似的两端向中心的双指针技巧还有力扣上的 N 数之和系列问题，后文 一个函数秒杀所有 nSum 问题 讲了这些题目的共性，甭管几数之和，解法肯定要穷举所有的数字组合，然后看看那个数字组合的和等于目标和嘛。比较聪明的方式是先排序，利用双指针技巧快速计算结果。

再说说 滑动窗口算法技巧，典型的快慢双指针，快慢指针中间就是滑动的「窗口」，主要用于解决子串问题。

文中最小覆盖子串这道题，让你寻找包含特定字符的最短子串，常规拍脑袋解法是什么？那肯定是类似字符串暴力匹配算法，用嵌套 for 循环穷举呗，平方级的复杂度。而滑动窗口技巧告诉你不用这么麻烦，可以用快慢指针遍历一次就求出答案，这就是教你聪明的穷举技巧。

还有回文串相关技巧，如果判断一个串是否是回文串，使用双指针从两端向中心检查，如果寻找回文子串，就从中心向两端扩散。后文 最长回文子串 使用了一种技巧同时处理了回文串长度为奇数或偶数的情况。

当然，寻找最长回文子串可以有更精妙的马拉车算法（Manacher 算法），不过，学习这个算法的性价比不高，有兴趣的读者可以自己了解一下。

最后说说 前缀和技巧 和 差分数组技巧。

如果频繁地让你计算子数组的和，每次用 for 循环去遍历肯定没问题，但前缀和技巧预计算一个 preSum​ 数组，就可以避免循环。

类似的，如果频繁地让你对子数组进行增减操作，也可以每次用 for 循环去操作，但差分数组技巧维护一个 diff​ 数组，也可以避免循环。

数组链表的技巧差不多就这些了，都比较固定，只要你都见过，运用出来的难度不算大，下面来说一说稍微有些难度的算法。

#二叉树系列算法

老读者都知道，二叉树的重要性我之前说了无数次，因为二叉树模型几乎是所有高级算法的基础，尤其是那么多人说对递归的理解不到位，更应该好好刷二叉树相关题目。

提示

在本站的二叉树章节，我会按照固定的公式和思维模式讲解了 150 道二叉树题目，可以手把手带你刷完二叉树分类的题目，迅速掌握递归思维。

东哥带你刷二叉树（纲领篇） 说过，二叉树题目的递归解法可以分两类思路，第一类是遍历一遍二叉树得出答案，第二类是通过分解问题计算出答案，这两类思路分别对应着 回溯算法核心框架 和 动态规划核心框架。

后续我会继续更新，根据博客的⑦天打卡，我想对这七天的基础进行一个复习，重刷；

总结一下单链表的基本技巧，每个技巧都对应着至少一道算法题：

1、合并两个有序链表

2、链表的分解

3、合并 k​ 个有序链表

4、寻找单链表的倒数第 k​ 个节点

5、寻找单链表的中点

6、判断单链表是否包含环并找出环起点

7、判断两个单链表是否相交并找出交点

这些解法都用到了双指针技巧，所以说对于单链表相关的题目，双指针的运用是非常广泛的，下面我们就来一个一个看。

合并两个有序链表

这是最基本的链表技巧，力扣第 21 题「合并两个有序链表open in new window」就是这个问题：

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

​

输入：l1 = [1,2,4], l2 = [1,3,4]  
输出：[1,1,2,3,4,4]  

示例 2：

输入：l1 = [], l2 = []  
输出：[]  

示例 3：

输入：l1 = [], l2 = [0]  
输出：[0]  

提示：

• 两个链表的节点数目范围是 [0, 50]​

• ​-100 <= Node.val <= 100​

• ​l1​ 和 l2​ 均按 非递减顺序 排列

ListNode* mergeTwoLists(ListNode* l1,ListNode* l2){
    ListNode* dummy = new ListNode(-1) , *p = dummy;
    ListNode* p1 = l1,*p2 = l2;
   while(p1 != NULL&&p2 != NULL){
       if (p1 -> val > p2 -> val){
           p->next = p2;
           p2 = p2->next;
       }
       else {
           p->next = p1;
           p1 = p1->next;
       }
       p = p->next;
   }
   if(p1 != NULL){
      p->next = p1;
   }
   if(p2 != NULL){
       p->next = p2;
   }
   return dummy->next;
}
这里我觉得先把dummy->next 的节点存下来，再把dummy进行释放更合适

我们的 while 循环每次比较 p1​ 和 p2​ 的大小，把较小的节点接到结果链表上，看如下 GIF：

​​

形象地理解，这个算法的逻辑类似于拉拉链，l1, l2​ 类似于拉链两侧的锯齿，指针 p​ 就好像拉链的拉索，将两个有序链表合并；或者说这个过程像蛋白酶合成蛋白质，l1, l2​ 就好比两条氨基酸，而指针 p​ 就好像蛋白酶，将氨基酸组合成蛋白质。

代码中还用到一个链表的算法题中是很常见的「虚拟头结点」技巧，也就是 ​dummy​​ 节点。你可以试试，如果不使用 dummy​ 虚拟节点，代码会复杂一些，需要额外处理指针 p​ 为空的情况。而有了 dummy​ 节点这个占位符，可以避免处理空指针的情况，降低代码的复杂性。

单链表的分解

直接看下力扣第 86 题「分隔链表open in new window」：

86. 分隔链表 | 力扣 open in new window | LeetCode open in new window |

给你一个链表的头节点 head​ 和一个特定值 x​ ，请你对链表进行分隔，使得所有 小于 x​ 的节点都出现在 大于或等于 x​ 的节点之前。

你应当 保留 两个分区中每个节点的初始相对位置。

示例 1：

​

输入：head = [1,4,3,2,5,2], x = 3  
输出：[1,2,2,4,3,5]  

示例 2：

输入：head = [2,1], x = 2  
输出：[1,2]  

提示：

• 链表中节点的数目在范围 [0, 200]​ 内
• ​-100 <= Node.val <= 100​
• ​-200 <= x <= 200​

在合并两个有序链表时让你合二为一，而这里需要分解让你把原链表一分为二。具体来说，我们可以把原链表分成两个小链表，一个链表中的元素大小都小于 x​，另一个链表中的元素都大于等于 x​，最后再把这两条链表接到一起，就得到了题目想要的结果。

#include <iostream>

ListNode* partition(ListNode* head,int x){
  ListNode *dummy1 = new ListNode(0);
  ListNode *dummy2 = new ListNode(0);
  ListNode *p1 = dummy1,* p2 = dummy2;
  ListNode *p1 = dummy1, *p2 = dummy2;
  ListNode *p = dummy1, *p2 = dummy2;
  ListNode *p = head;
  while(p ！= NULL){
    if(p -> val >=x){
      p2->next = p;
      p2 = p2->next;
    }
    else {
      p1->next = p;
      p1 = p1->next;
    }
    ListNode * temp = p->next;
    p->next = NULL;
    p = temp;
  }
  p1 -> next = dummy2->next;
  return dummy1->next;
}

这里的断开节点很细节，我理解了好一会儿，大家仔细琢磨一下

点击这里,这里是图解（这是我第一次用markdown超链接）

如果不进行断点会出现环：

点击这里,这里是不进行断点的结果；

总的来说，如果我们需要把原链表的节点接到新链表上，而不是 new 新节点来组成新链表的话，那么断开节点和原链表之间的链接可能是必要的。那其实我们可以养成一个好习惯，但凡遇到这种情况，就把原链表的节点断开，这样就不会出错了。

#合并 k 个有序链表

看下力扣第 23 题「合并K个升序链表open in new window」：

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]  
输出：[1,1,2,3,4,4,5,6]  
解释：链表数组如下：  
[  
  1->4->5,  
  1->3->4,  
  2->6  
]  
将它们合并到一个有序链表中得到。  
1->1->2->3->4->4->5->6  

示例 2：

输入：lists = []  
输出：[]  

示例 3：

输入：lists = [[]]  
输出：[]  

提示：

• ​k == lists.length​
• ​0 <= k <= 10^4​
• ​0 <= lists[i].length <= 500​
• ​-10^4 <= lists[i][j] <= 10^4​
• ​lists[i]​ 按 升序 排列
• ​lists[i].length​ 的总和不超过 10^4​

合并 k​ 个有序链表的逻辑类似合并两个有序链表，难点在于，如何快速得到 k​ 个节点中的最小节点，接到结果链表上？

这里我们就要用到 优先级队列（二叉堆） 这种数据结构，把链表节点放入一个最小堆，就可以每次获得 k​ 个节点中的最小节点：

ListNode* mergeKLists(vector<ListNode*>& lists) {
    if (lists.empty()) return nullptr;
    // 虚拟头结点
    ListNode* dummy = new ListNode(-1);
    ListNode* p = dummy;
    // 优先级队列，最小堆
    priority_queue<ListNode*, vector<ListNode*>, function<bool(ListNode*, ListNode*)>> pq(
            [] (ListNode* a, ListNode* b) { return a->val > b->val; });
    // 将 k 个链表的头结点加入最小堆
    for (auto head : lists) {
        if (head != nullptr) {
            pq.push(head);
        }
    }

    while (!pq.empty()) {
        // 获取最小节点，接到结果链表中
        ListNode* node = pq.top();
        pq.pop();
        p->next = node;
        if (node->next != nullptr) {
            pq.push(node->next);
        }
        // p 指针不断前进
        p = p->next;
    }
    return dummy->next;
}

优先队列 pq​ 中的元素个数最多是 k​，所以一次 poll​ 或者 add​ 方法的时间复杂度是 O(logk)​；所有的链表节点都会被加入和弹出 pq​，所以算法整体的时间复杂度是 ​O(Nlogk)​ ​ ，其中 ​k​​ 是链表的条数，​​N​​ 是这些链表的节点总数。

先写到这里，学不完了，明天继续补充；

昨天那个优先队列和lamba表达式我学的不好，还没有掌握，这道困难题放到最后；

单链表的倒数第 k 个节点

从前往后寻找单链表的第 k​ 个节点很简单，一个 for 循环遍历过去就找到了，但是如何寻找从后往前数的第 k​ 个节点呢？

那你可能说，假设链表有 n​ 个节点，倒数第 k​ 个节点就是正数第 n - k + 1​ 个节点，不也是一个 for 循环的事儿吗？

是的，但是算法题一般只给你一个 ListNode​ 头结点代表一条单链表，你不能直接得出这条链表的长度 n​，而需要先遍历一遍链表算出 n​ 的值，然后再遍历链表计算第 n - k + 1​ 个节点。

也就是说，这个解法需要遍历两次链表才能得到出倒数第 k​ 个节点。

那么，我们能不能只遍历一次链表，就算出倒数第 k​ 个节点？可以做到的，如果是面试问到这道题，面试官肯定也是希望你给出只需遍历一次链表的解法。

这个解法就比较巧妙了，假设 k = 2​，思路如下：

首先，我们先让一个指针 p1​ 指向链表的头节点 head​，然后走 k​ 步：

​​

现在的 p1​，只要再走 n - k​ 步，就能走到链表末尾的空指针了对吧？

趁这个时候，再用一个指针 p2​ 指向链表头节点 head​：

​​

接下来就很显然了，让 p1​ 和 p2​ 同时向前走，p1​ 走到链表末尾的空指针时前进了 n - k​ 步，p2​ 也从 head​ 开始前进了 n - k​ 步，停留在第 n - k + 1​ 个节点上，即恰好停链表的倒数第 k​ 个节点上：

​​

这样，只遍历了一次链表，就获得了倒数第 k​ 个节点 p2​。

ListNode* findFromEnd(ListNode* head, int k) {
    ListNode* p1 = head;
    // p1 先走 k 步
    for (int i = 0; i < k; i++) {
        p1 = p1 -> next;
    }
    ListNode* p2 = head;
    // p1 和 p2 同时走 n - k 步
    while (p1 != nullptr) {
        p2 = p2 -> next;
        p1 = p1 -> next;
    }
    // p2 现在指向第 n - k + 1 个节点，即倒数第 k 个节点
    return p2;
}

当然，如果用 big O 表示法来计算时间复杂度，无论遍历一次链表和遍历两次链表的时间复杂度都是 O(N)​，但上述这个算法更有技巧性。

很多链表相关的算法题都会用到这个技巧，比如说力扣第 19 题「删除链表的倒数第 N 个结点open in new window」：

给你一个链表，删除链表的倒数第 n​ 个结点，并且返回链表的头结点。

示例 1：

​

输入：head = [1,2,3,4,5], n = 2  
输出：[1,2,3,5]  

示例 2：

输入：head = [1], n = 1  
输出：[]  

示例 3：

输入：head = [1,2], n = 1  
输出：[1]  

提示：

• 链表中结点的数目为 sz​
• ​1 <= sz <= 30​
• ​0 <= Node.val <= 100​
• ​1 <= n <= sz​

进阶： 你能尝试使用一趟扫描实现吗？

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummy = new ListNode(-1);
    dummy->next = head;
    ListNode* x = findFromEnd(dummy, n + 1);
    x->next = x->next->next;
    return dummy->next;
}

ListNode* findFromEnd(ListNode* head, int k) {
    // 代码见上文
}

这段代码逻辑没问题上传到leetcode会报错，我还是提倡那一个节点存储下一节点，然后在对其释放；

这个逻辑就很简单了，要删除倒数第 n​ 个节点，就得获得倒数第 n + 1​ 个节点的引用，可以用我们实现的 findFromEnd​ 来操作。

不过注意我们又使用了虚拟头结点的技巧，也是为了防止出现空指针的情况，比如说链表总共有 5 个节点，题目就让你删除倒数第 5 个节点，也就是第一个节点，那按照算法逻辑，应该首先找到倒数第 6 个节点。但第一个节点前面已经没有节点了，这就会出错。

但有了我们虚拟节点 dummy​ 的存在，就避免了这个问题，能够对这种情况进行正确的删除。

#单链表的中点

力扣第 876 题「链表的中间结点open in new window」就是这个题目，问题的关键也在于我们无法直接得到单链表的长度 n​，常规方法也是先遍历链表计算 n​，再遍历一次得到第 n / 2​ 个节点，也就是中间节点。

如果想一次遍历就得到中间节点，也需要耍点小聪明，使用「快慢指针」的技巧：

我们让两个指针 slow​ 和 fast​ 分别指向链表头结点 head​。

每当慢指针 ​slow​​ 前进一步，快指针 ​fast​​ 就前进两步，这样，当 ​fast​​ 走到链表末尾时，​​slow​​ 就指向了链表中点。

ListNode* middleNode(ListNode* head) {
    // 快慢指针初始化指向 head
    ListNode* slow = head;
    ListNode* fast = head;
    // 快指针走到末尾时停止
    while (fast != nullptr && fast->next != nullptr) {
        // 慢指针走一步，快指针走两步
        slow = slow->next;
        fast = fast->next->next;
    }
    // 慢指针指向中点
    return slow;
}

判断链表是否包含环

判断链表是否包含环属于经典问题了，解决方案也是用快慢指针：

每当慢指针 slow​ 前进一步，快指针 fast​ 就前进两步。

如果 fast​ 最终遇到空指针，说明链表中没有环；如果 fast​ 最终和 slow​ 相遇，那肯定是 fast​ 超过了 slow​ 一圈，说明链表中含有环。

只需要把寻找链表中点的代码稍加修改就行了：

bool hasCycle(ListNode* head) {
    // 初始化快慢指针，指向头结点
    ListNode* slow = head;
    ListNode* fast = head;
    // 快指针到尾部时停止
    while (fast && fast->next) {
        // 慢指针走一步，快指针走两步
        slow = slow->next;
        fast = fast->next->next;
        // 快慢指针相遇，说明含有环
        if (slow == fast) {
            return true;
        }
    }
    // 不包含环
    return false;
}

当然，这个问题还有进阶版，也是力扣第 142 题「环形链表 IIopen in new window」：如果链表中含有环，如何计算这个环的起点？

为了避免读者迷惑，举个例子，环的起点是指下面这幅图中的节点 2：

​​

ListNode* detectCycle(ListNode* head) {
    ListNode* fast = head;
    ListNode* slow = head;
    while (fast != nullptr && fast->next != nullptr) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) break;

    }
    // 上面的代码类似 hasCycle 函数
    if (fast == nullptr || fast->next == nullptr) {
        // fast 遇到空指针说明没有环
        return nullptr;
    }

    // 重新指向头结点
    slow = head;

    // 快慢指针同步前进，相交点就是环起点
    while (slow != fast) {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

可以看到，当快慢指针相遇时，让其中任一个指针指向头节点，然后让它俩以相同速度前进，再次相遇时所在的节点位置就是环开始的位置。

为什么要这样呢？这里简单说一下其中的原理。

我们假设快慢指针相遇时，慢指针 slow​ 走了 k​ 步，那么快指针 fast​ 一定走了 2k​ 步：

​​

​fast​ 一定比 slow​ 多走了 k​ 步，这多走的 k​ 步其实就是 fast​ 指针在环里转圈圈，所以 k​ 的值就是环长度的「整数倍」。

假设相遇点距环的起点的距离为 m​，那么结合上图的 slow​ 指针，环的起点距头结点 head​ 的距离为 k - m​，也就是说如果从 head​ 前进 k - m​ 步就能到达环起点。

巧的是，如果从相遇点继续前进 k - m​ 步，也恰好到达环起点。因为结合上图的 fast​ 指针，从相遇点开始走k步可以转回到相遇点，那走 k - m​ 步肯定就走到环起点了：

​​

所以，只要我们把快慢指针中的任一个重新指向 head​，然后两个指针同速前进，k - m​ 步后一定会相遇，相遇之处就是环的起点了。

#两个链表是否相交

这个问题有意思，也是力扣第 160 题「相交链表open in new window」函数签名如下：

ListNode getIntersectionNode(ListNode headA, ListNode headB);

给你输入两个链表的头结点 headA​ 和 headB​，这两个链表可能存在相交。

如果相交，你的算法应该返回相交的那个节点；如果没相交，则返回 null。

比如题目给我们举的例子，如果输入的两个链表如下图：

​​

那么我们的算法应该返回 c1​ 这个节点。

这个题直接的想法可能是用 HashSet​ 记录一个链表的所有节点，然后和另一条链表对比，但这就需要额外的空间。

如果不用额外的空间，只使用两个指针，你如何做呢？

难点在于，由于两条链表的长度可能不同，两条链表之间的节点无法对应：

​​

如果用两个指针 p1​ 和 p2​ 分别在两条链表上前进，并不能同时走到公共节点，也就无法得到相交节点 c1​。

解决这个问题的关键是，通过某些方式，让 ​p1​​ 和 ​p2​​ 能够同时到达相交节点 ​c1​​。

所以，我们可以让 p1​ 遍历完链表 A​ 之后开始遍历链表 B​，让 p2​ 遍历完链表 B​ 之后开始遍历链表 A​，这样相当于「逻辑上」两条链表接在了一起。

如果这样进行拼接，就可以让 p1​ 和 p2​ 同时进入公共部分，也就是同时到达相交节点 c1​：

​​

那你可能会问，如果说两个链表没有相交点，是否能够正确的返回 null 呢？

这个逻辑可以覆盖这种情况的，相当于 c1​ 节点是 null 空指针嘛，可以正确返回 null。

按照这个思路，可以写出如下代码：

ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    // p1 指向 A 链表头结点，p2 指向 B 链表头结点
    ListNode *p1 = headA, *p2 = headB;
    while (p1 != p2) {
        // p1 走一步，如果走到 A 链表末尾，转到 B 链表
        if (p1 == nullptr) p1 = headB;
        else               p1 = p1->next;
        // p2 走一步，如果走到 B 链表末尾，转到 A 链表
        if (p2 == nullptr) p2 = headA;
        else               p2 = p2->next;
    }
    return p1; // 返回交点
}

有读者提到，如果把两条链表首尾相连，那么「寻找两条链表的交点」的问题转换成了前面讲的「寻找环起点」的问题：

​​

说实话我没有想到这种思路，不得不说这是一个很巧妙的转换！不过需要注意的是，这道题说不让你改变原始链表的结构，所以你把题目输入的链表转化成环形链表求解之后记得还要改回来，否则无法通过。

另外，还有读者提到，既然「寻找两条链表的交点」的核心在于让 p1​ 和 p2​ 两个指针能够同时到达相交节点 c1​，那么可以通过预先计算两条链表的长度来做到这一点，具体代码如下：

ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    int lenA = 0, lenB = 0;
    // 计算两条链表的长度
    for (ListNode *p1 = headA; p1 != nullptr; p1 = p1->next) {
        lenA++;
    }
    for (ListNode *p2 = headB; p2 != nullptr; p2 = p2->next) {
        lenB++;
    }
    // 让 p1 和 p2 到达尾部的距离相同
    ListNode *p1 = headA, *p2 = headB;
    if (lenA > lenB) {
        // p1 先走过 lenA-lenB 步
        for (int i = 0; i < lenA - lenB; i++) {
            p1 = p1->next;
        }
    } else {
        // p2 先走过 lenB-lenA 步
        for (int i = 0; i < lenB - lenA; i++) {
            p2 = p2->next;
        }
    }
    // 看两个指针是否会相同，p1 == p2 时有两种情况：
    // 1、要么是两条链表不相交，他俩同时走到尾部空指针
    // 2、要么是两条链表相交，他俩走到两条链表的相交点
    while (p1 != p2) {
        p1 = p1->next;
        p2 = p2->next;  
    }
    return p1;
}

虽然代码多一些，但是时间复杂度是还是 O(N)​，而且会更容易理解一些。

还是跟我之前笔记一样的内容；

一、快慢指针技巧

数组问题中比较常见的快慢指针技巧，是让你原地修改数组。

比如说看下力扣第 26 题「删除有序数组中的重复项open in new window」，让你在有序数组去重：

‍

给你一个 升序排列 的数组 nums​ ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums​ 中唯一元素的个数。

考虑 nums​ 的唯一元素的数量为 k​ ，你需要做以下事情确保你的题解可以被通过：

• 更改数组 nums​ ，使 nums​ 的前 k​ 个元素包含唯一元素，并按照它们最初在 nums​ 中出现的顺序排列。nums​ 的其余元素与 nums​ 的大小不重要。
• 返回 k​ 。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

示例 1：

输入：nums = [1,1,2]  
输出：2, nums = [1,2,_]  
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。  

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]  
输出：5, nums = [0,1,2,3,4]  
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。  

提示：

• ​1 <= nums.length <= 3 * 10<sup>4</sup>​
• ​-10<sup>4</sup><span> </span><= nums[i] <= 10<sup>4</sup>​
• ​nums​ 已按 升序 排列

函数签名如下：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

int removeDuplicates(vector<int>& nums);

简单解释一下什么是原地修改：

如果不是原地修改的话，我们直接 new 一个 int[]​ 数组，把去重之后的元素放进这个新数组中，然后返回这个新数组即可。

但是现在题目让你原地删除，不允许 new 新数组，只能在原数组上操作，然后返回一个长度，这样就可以通过返回的长度和原始数组得到我们去重后的元素有哪些了。

由于数组已经排序，所以重复的元素一定连在一起，找出它们并不难。但如果毎找到一个重复元素就立即原地删除它，由于数组中删除元素涉及数据搬移，整个时间复杂度是会达到 O(N^2)​。

高效解决这道题就要用到快慢指针技巧：

我们让慢指针 slow​ 走在后面，快指针 fast​ 走在前面探路，找到一个不重复的元素就赋值给 slow​ 并让 slow​ 前进一步。

这样，就保证了 nums[0..slow]​ 都是无重复的元素，当 fast​ 指针遍历完整个数组 nums​ 后，nums[0..slow]​ 就是整个数组去重之后的结果。

看代码：

java 🟢cpp 🤖python 🤖go 🤖javascript 🤖

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

int removeDuplicates(vector<int>& nums) {
    if (nums.size() == 0) {
        return 0;
    }
    int slow = 0, fast = 0;
    while (fast < nums.size()) {
        if (nums[fast] != nums[slow]) {
            slow++;
            // 维护 nums[0..slow] 无重复
            nums[slow] = nums[fast];
        }
        fast++;
    }
    // 数组长度为索引 + 1
    return slow + 1;
}

‍

算法执行的过程如下 GIF 图：

​​

再简单扩展一下，看看力扣第 83 题「删除排序链表中的重复元素open in new window」，如果给你一个有序的单链表，如何去重呢？

其实和数组去重是一模一样的，唯一的区别是把数组赋值操作变成操作指针而已，你对照着之前的代码来看：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

ListNode* deleteDuplicates(ListNode* head) {
    if (head == nullptr) return nullptr;
    ListNode* slow = head;  // 当前元素
    ListNode* fast = head;  // 下一个元素
    while (fast != nullptr) {
        if (fast->val != slow->val) {
            // 当前元素的下一个元素设置为下一个不相等的元素
            slow->next = fast;
            // 当前元素向后移动
            slow = slow->next;
        }
        // 下一个元素向后移动
        fast = fast->next;
    }
    // 断开与后面重复元素的连接
    slow->next = nullptr;
    return head;
}

算法执行的过程请看下面这个 GIF：

​​

注

这里可能有读者会问，链表中那些重复的元素并没有被删掉，就让这些节点在链表上挂着，合适吗？

这就要探讨不同语言的特性了，像 Java/Python 这类带有垃圾回收的语言，可以帮我们自动找到并回收这些「悬空」的链表节点的内存，而像 C++ 这类语言没有自动垃圾回收的机制，确实需要我们编写代码时手动释放掉这些节点的内存。

不过话说回来，就算法思维的培养来说，我们只需要知道这种快慢指针技巧即可。

除了让你在有序数组/链表中去重，题目还可能让你对数组中的某些元素进行「原地删除」 。

比如力扣第 27 题「移除元素open in new window」，看下题目：

‍

给你一个数组 nums​ 和一个值 val​，你需要 原地 移除所有数值等于 val​ 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1)​ 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以 「引用」 方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3  
输出：2, nums = [2,2]  
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。  

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2  
输出：5, nums = [0,1,4,0,3]  
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。  

提示：

• ​0 <= nums.length <= 100​
• ​0 <= nums[i] <= 50​
• ​0 <= val <= 100​

函数签名如下：

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

int removeElement(vector<int>& nums, int val);

题目要求我们把 nums​ 中所有值为 val​ 的元素原地删除，依然需要使用快慢指针技巧：

如果 fast​ 遇到值为 val​ 的元素，则直接跳过，否则就赋值给 slow​ 指针，并让 slow​ 前进一步。

这和前面说到的数组去重问题解法思路是完全一样的，就不画 GIF 了，直接看代码：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

int removeElement(vector<int>& nums, int val) {
    int fast = 0, slow = 0;
    while (fast < nums.size()) {
        if (nums[fast] != val) {
            nums[slow] = nums[fast];
            slow++;
        }
        fast++;
    }
    return slow;
}

注意这里和有序数组去重的解法有一个细节差异，我们这里是先给 nums[slow]​ 赋值然后再给 slow++​，这样可以保证 nums[0..slow-1]​ 是不包含值为 val​ 的元素的，最后的结果数组长度就是 slow​。

实现了这个 removeElement​ 函数，接下来看看力扣第 283 题「移动零open in new window」：

给你输入一个数组 nums​，请你原地修改，将数组中的所有值为 0 的元素移到数组末尾，函数签名如下：

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

void moveZeroes(vector<int>& nums);

比如说给你输入 nums = [0,1,4,0,2]​，你的算法没有返回值，但是会把 nums​ 数组原地修改成 [1,4,2,0,0]​。

结合之前说到的几个题目，你是否有已经有了答案呢？

题目让我们将所有 0 移到最后，其实就相当于移除 nums​ 中的所有 0，然后再把后面的元素都赋值为 0 即可。

所以我们可以复用上一题的 removeElement​ 函数：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

void moveZeroes(vector<int>& nums) {
    // 去除 nums 中的所有 0，返回不含 0 的数组长度
    int p = removeElement(nums, 0);
    // 将 nums[p..] 的元素赋值为 0
    for (; p < nums.size(); p++) {
        nums[p] = 0;
    }
}

// 见上文代码实现
int removeElement(vector<int>& nums, int val);

到这里，原地修改数组的这些题目就已经差不多了。数组中另一大类快慢指针的题目就是「滑动窗口算法」。

我在另一篇文章 滑动窗口算法核心框架详解 给出了滑动窗口的代码框架：

‍

/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
    unordered_map<char, int> window;

    int left = 0, right = 0;
    while (right < s.size()) {
        char c = s[right];
        // 右移（增大）窗口
        right++;
        // 进行窗口内数据的一系列更新

        while (window needs shrink) {
            char d = s[left];
            // 左移（缩小）窗口
            left++;
            // 进行窗口内数据的一系列更新
        }
    }
}

具体的题目本文就不重复了，这里只强调滑动窗口算法的快慢指针特性：

​left​ 指针在后，right​ 指针在前，两个指针中间的部分就是「窗口」，算法通过扩大和缩小「窗口」来解决某些问题。

#二、左右指针的常用算法

1、二分查找

我在另一篇文章 二分查找框架详解 中有详细探讨二分搜索代码的细节问题，这里只写最简单的二分算法，旨在突出它的双指针特性：

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

int binarySearch(vector<int>& nums, int target) {
    // 一左一右两个指针相向而行
    int left = 0, right = nums.size() - 1;
    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1; 
        else if (nums[mid] > target)
            right = mid - 1;
    }
    return -1;
}

2、两数之和

看下力扣第 167 题「两数之和 IIopen in new window」：

给你一个下标从 1 开始的整数数组 numbers​ ，该数组已按 ** 非递减顺序排列 **，请你从数组中找出满足相加之和等于目标数 target​ 的两个数。如果设这两个数分别是 numbers[index<sub>1</sub>]​ 和 numbers[index<sub>2</sub>]​ ，则 1 <= index<sub>1</sub><span> </span>< index<sub>2</sub><span> </span><= numbers.length​ 。

以长度为 2 的整数数组 [index<sub>1</sub>, index<sub>2</sub>]​ 的形式返回这两个整数的下标 index<sub>1</sub>​ 和index<sub>2</sub>​。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9  
输出：[1,2]  
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

输入：numbers = [2,3,4], target = 6  
输出：[1,3]  
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。

示例 3：

输入：numbers = [-1,0], target = -1  
输出：[1,2]  
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。  

提示：

• ​2 <= numbers.length <= 3 * 10<sup>4</sup>​
• ​-1000 <= numbers[i] <= 1000​
• ​numbers​ 按 非递减顺序 排列
• ​-1000 <= target <= 1000​
• 仅存在一个有效答案

只要数组有序，就应该想到双指针技巧。这道题的解法有点类似二分查找，通过调节 left​ 和 right​ 就可以调整 sum​ 的大小：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

vector<int> twoSum(vector<int>& nums, int target) {
    // 一左一右两个指针相向而行
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) {
            // 题目要求的索引是从 1 开始的
            return {left + 1, right + 1};
        } else if (sum < target) {
            left++; // 让 sum 大一点
        } else if (sum > target) {
            right--; // 让 sum 小一点
        }
    }
    return {-1, -1};
}

我在另一篇文章 一个函数秒杀所有 nSum 问题 中也运用类似的左右指针技巧给出了 nSum​ 问题的一种通用思路，这里就不做赘述了。

3、反转数组

一般编程语言都会提供 reverse​ 函数，其实这个函数的原理非常简单，力扣第 344 题「反转字符串open in new window」就是类似的需求，让你反转一个 char[]​ 类型的字符数组，我们直接看代码吧：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

void reverseString(vector<char>& s) {
    // 一左一右两个指针相向而行
    int left = 0, right = s.size() - 1;
    while (left < right) {
        // 交换 s[left] 和 s[right]
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

4、回文串判断

首先明确一下，回文串就是正着读和反着读都一样的字符串。

比如说字符串 aba​ 和 abba​ 都是回文串，因为它们对称，反过来还是和本身一样；反之，字符串 abac​ 就不是回文串。

现在你应该能感觉到回文串问题和左右指针肯定有密切的联系，比如让你判断一个字符串是不是回文串，你可以写出下面这段代码：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

bool isPalindrome(string s) {
    // 一左一右两个指针相向而行
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s[left] != s[right]) { // 如果不相同，就不是回文串
            return false;
        }
        left++;
        right--;
    }
    return true;
}

那接下来我提升一点难度，给你一个字符串，让你用双指针技巧从中找出最长的回文串，你会做吗？

这就是力扣第 5 题「最长回文子串open in new window」：

‍

给你一个字符串 s​，找到 s​ 中最长的回文子串。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例 1：

输入：s = "babad"  
输出："bab"  
解释："aba" 同样是符合题意的答案。  

示例 2：

输入：s = "cbbd"  
输出："bb"  

提示：

• ​1 <= s.length <= 1000​
• ​s​ 仅由数字和英文字母组成

函数签名如下：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

string longestPalindrome(string s);

找回文串的难点在于，回文串的的长度可能是奇数也可能是偶数，解决该问题的核心是从中心向两端扩散的双指针技巧。

如果回文串的长度为奇数，则它有一个中心字符；如果回文串的长度为偶数，则可以认为它有两个中心字符。所以我们可以先实现这样一个函数：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

// 在 s 中寻找以 s[l] 和 s[r] 为中心的最长回文串
string palindrome(string s, int l, int r) {
    // 防止索引越界
    while (l >= 0 && r < s.length()
            && s[l] == s[r]) {
        // 双指针，向两边展开
        l--; r++;
    }
    // 返回以 s[l] 和 s[r] 为中心的最长回文串
    return s.substr(l + 1, r - l - 1);
}

这样，如果输入相同的 l​ 和 r​，就相当于寻找长度为奇数的回文串，如果输入相邻的 l​ 和 r​，则相当于寻找长度为偶数的回文串。

那么回到最长回文串的问题，解法的大致思路就是：

for 0 <= i < len(s):
    找到以 s[i] 为中心的回文串
    找到以 s[i] 和 s[i+1] 为中心的回文串
    更新答案

翻译成代码，就可以解决最长回文子串这个问题：

‍

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码不保证正确性，仅供参考。如有疑惑，可以参照我写的 java 代码对比查看。

string longestPalindrome(string s) {
    string res = "";
    for (int i = 0; i < s.length(); i++) {
        // 以 s[i] 为中心的最长回文子串
        string s1 = palindrome(s, i, i);
        // 以 s[i] 和 s[i+1] 为中心的最长回文子串
        string s2 = palindrome(s, i, i + 1);
        // res = longest(res, s1, s2)
        res = res.length() > s1.length() ? res : s1;
        res = res.length() > s2.length() ? res : s2;
    }
    return res;
}

‍

你应该能发现最长回文子串使用的左右指针和之前题目的左右指针有一些不同：之前的左右指针都是从两端向中间相向而行，而回文子串问题则是让左右指针从中心向两端扩展。不过这种情况也就回文串这类问题会遇到，所以我也把它归为左右指针了。

---

---

《labuladong 的算法笔记》已经出版，关注公众号查看详情；后台回复「 全家桶 」可下载配套 PDF 和刷题全家桶：

​​

‍

‍