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

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

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

本篇是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​​ 是这些链表的节点总数。

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