leetcode刷题笔记

labuladong笔记进度（Java为主）

1.两数之和 题意

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入输出案例

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

只会存在一个有效答案

题解（C++）

就用两个标识符，挨个找，找到一个就返回。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i,j;
        for(i=0;i<nums.size()-1;i++) //这里特地控制了一下，避免数组越界
        {
            for(j=i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]==target){ //果然还是暴力法
                    return {i,j};
                }
            }
        }
        return {i,j};
    }
};

21. 合并两个有序链表

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

示例 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 均按 非递减顺序 排列

题解

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
         // 虚拟头结点
    ListNode* dummy = new ListNode(-1), *p = dummy;
    ListNode* p1 = list1, *p2 = list2;
    
    while (p1 != NULL && p2 != NULL) {//但凡有一个走完了，循环就停止了

        // 比较 p1 和 p2 两个指针
        // 将值较小的的节点接到 p 指针
        if (p1->val > p2->val) {
            p->next = p2;
            p2 = p2->next;
        } else {
            p->next = p1;
            p1 = p1->next;
        }
        // p 指针不断前进
        p = p->next;
    }
    
    if (p1 != NULL) { //这里适用于任意长度的链表，因为p1或p2没有被比较的结点直接排在p的最后就可以了
        p->next = p1;
    }
    
    if (p2 != NULL) {
        p->next = p2;
    }
    
    return dummy->next;//这里就是dummy结点的最终收尾。p指针在运行完函数后基本就是指向答案末尾的那个地方，不能作为return返回。得用dummy指针。
    }
};

86. 分隔链表

给你一个链表的头节点 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]

题解

当题解里的链表结点过多时，可以画图记忆链表结点。或者就是凭大脑记忆。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
//题目的输入看似是列表，其实是有内部函数将其转化为链表节点的。

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {

    // 存放小于 x 的链表的虚拟头结点
    ListNode* dummy1 = new ListNode(-1); //初始化一个空结点，初始值为-1，指针指向为dummy1

    // 存放大于等于 x 的链表的虚拟头结点
    ListNode* dummy2 = new ListNode(-1); //初始化一个空结点，初始值为-1，指针指向为dummy2

    // p1, p2 指针负责生成结果链表
    ListNode* p1 = dummy1, * p2 = dummy2;

    // p 负责遍历原链表，类似合并两个有序链表的逻辑
    // 这里是将一个链表分解成两个链表
    ListNode* p = head;  //以上指针一开始都在头节点的位置。

    while (p != nullptr) {
        if (p->val >= x) {
            p2->next = p;
            p2 = p2->next;//往后接着移动
        } else {
            p1->next = p; //较小的那个
            p1 = p1->next; //移动到选中的结点
        }

        // 断开原链表中的每个节点的 next 指针
        ListNode* temp = p->next; 
        p->next = nullptr;
        p = temp; //temp的作用是帮助置空p的next结点，然后一步一步在原链表的基础上往后移。
    }
    // 连接两个链表
    p1->next = dummy2->next;

    return dummy1->next;
    }
};

算法技巧

数组/单链表系列算法

单链表常考的技巧就是双指针。

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

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

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

类似的两端向中心的双指针技巧还有力扣上的 N 数之和系列问题，前文 一个函数秒杀所有 nSum 问题 。

比较聪明的方式是先排序，利用双指针技巧快速计算结果。

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

文中最小覆盖子串这道题，让你寻找包含特定字符的最短子串，常规拍脑袋解法是什么？那肯定是类似字符串暴力匹配算法，用嵌套 for 循环穷举呗，平方级的复杂度。

而滑动窗口技巧告诉你不用这么麻烦，可以用快慢指针遍历一次就求出答案，这就是教你聪明的穷举技巧。

但是，就好像二分搜索只能运用在有序数组上一样，滑动窗口也是有其限制的，就是你必须明确的知道什么时候应该扩大窗口，什么时候该收缩窗口。比方说，我们潜意识地假设扩大窗口会让窗口内元素之和变大，反之则变小，以此构建滑动窗口算法。但要注意这个假设的前提是数组元素都是非负数，如果存在负数，那么这个假设就不成立，也就无法确定滑动窗口的扩大和缩小的时机。

还有回文串相关技巧，如果判断一个串是否是回文串，使用双指针从两端向中心检查，如果寻找回文子串，就从中心向两端扩散。

当然，寻找最长回文子串可以有更精妙的马拉车算法（Manacher 算法），不过，学习这个算法的性价比不高，没什么必要掌握。

前缀和技巧 和 差分数组技巧。

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

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

二叉树系列

二叉树模型几乎是所有高级算法的基础。

二叉树题目的递归解法可以分两类思路，第一类是遍历一遍二叉树得出答案（回溯），第二类是通过分解问题计算出答案（动态规划）。

回溯算法本质就是遍历一棵多叉树。

链表的算法题：「虚拟头结点」技巧

也就是 dummy 节点。
如果不使用 dummy 虚拟节点，代码会复杂一些，需要额外处理指针 p 为空的情况。
而有了 dummy 节点这个占位符，可以避免处理空指针的情况，降低代码的复杂性。

什么时候需要用虚拟头结点？

当你需要创造一条新链表的时候，可以使用虚拟头结点简化边界情况的处理。

比如说，让你把两条有序链表合并成一条新的有序链表，是不是要创造一条新链表？再比你想把一条链表分解成两条链表，是不是也在创造新链表？这些情况都可以使用虚拟头结点简化边界情况的处理。

语法精进

new ListNode常用方法