【代码随想录学习笔记】

写在前面

• 这是关于 代码随想录的学习笔记,接下来也会不断更新

• 题目都是超链接(蓝色有下划线的字体),可以直接跳转至对应题目(一般都在力扣上)

• 如果有想法,也欢迎在评论区和我讨论,我将与大家一同进步

第零章 算法性能分析

• 减少时间复杂度的方式:避免使用多层嵌套循环

• 减少空间复杂度的方式:(一般来说要牺牲空间复杂度来优化时间复杂度)避免新建数组

第一章 数组

理论知识

数组基础

• 数组是存放在连续内存空间上的相同类型数据的集合
• 数组可以方便的通过下标索引的方式获取到下标下对应的数据(下标索引其实是地址的一种更方便的使用形式)
• 数组下标都是从0开始的(在任何语言中通用)
• 数组内存空间的地址是连续的(不能删除,只能覆盖) ==> 删除数组中元素时要移动其他元素

二分查找

• 不严格单调的数组

典型例题

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int middle = left + (right - left) / 2;
            if (target > nums[middle]) {
                left = middle + 1;
            } else if (target < nums[middle]) {
                right = middle - 1;
            } else {
                return middle;
            }
        }
        return -1;
    }
};

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size();
        while (left < right) {
            int middle = left + (right - left) >> 1;
            if (target > nums[middle]) {
                left = middle + 1;
            } else if (target < nums[middle]) {
                right = middle;
            } else {
                return middle;
            }
        }
        return -1;
    }
};

• left,right的设置取决于你的合法区间的设置
  • 如果是闭区间,使用int left = 0, right = nums.size() - 1;
  • 如果是左闭右开区间,使用int left = 0, right = nums.size();
• while的条件判断取<还是<=和上面的条件要求一致,如果可以取等即代表使用了闭区间
• >>和<<可能会被忽视,但是后面可以用于状态压缩
• 要注意所有的分支都应当返回结果
• 注意在middle的计算中出现了加法运算,要避免数据超出int所表示的范围(c++/c)

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1
        while left <= right:
            middle = left + (right - left) // 2
            if target > nums[middle]:
                left = middle + 1
            elif target < nums[middle]:
                right = middle - 1
            else:
                return middle
        return -1

• python要注意缩进
• 因为python中数据的隐式转换更加智能,所以注意区分/和//的区别,防止得出的数据不是自己想要的数据类型
  • /是浮点数除法
  • //为整数除法(与c++一致)

35. 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

提示:

• 1 <= nums.length <= 10^4
• -10^4 <= nums[i] <= 10^4
• nums 为 无重复元素 的 升序 排列数组
• -10^4 <= target <= 10^4

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int middle = (left + right) >> 1;
            if (target > nums[middle]) { // 目标值在右区间
                left = middle + 1;
            } else if (target < nums[middle]) { // 目标值在左区间
                right = middle - 1;
            } else {
                return middle; // 目标值在中间
            }
        }
        return left; //目标值不在区间之内
        // 在所有元素之前 ==> 0 ==> 一直更新右边界 ==> left
        // 在所有元素之后 ==> num.size() ==> 一直更新左边界 ==> left
        // 在元素集合内部 ==> 更新左右边界,但是不断趋向于目标值,直到left和right翻转 ==> left 
        
    }
};

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1
        while left <= right:
            middle = (left + right) // 2
            if nums[middle] < target:
                left = middle + 1
            elif nums[middle] > target:
                right = middle - 1
            else:
                return middle
        return left

• 和一般的二分查找没有太大区别,主要在于没有找到时的返回值上:二分查找会不断靠近目标值,停止的位置便是数据应当插入的位置,left在变化中会转移到right的后面,恰好是目标位置

• 暴力解法是直接遍历数组,没有什么技术含量

34. 在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

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

提示：

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        int middle, point = -1;
        bool flag = false; // 找到目标数据则为true
        vector<int> ans(2, -1);
        while (left <= right) {
            middle = (right + left) / 2;
            if (target > nums[middle]) {
                left = middle + 1;
            } else if (target < nums[middle]) {
                right = middle - 1;
            } else {
                point = middle;
                flag = true;
                break;
            }
        }
        // 找到之后向左右延伸,这里使用了for循环来寻找,当然也可以使用while循环
        if (flag) {
            for (int i = point; i < nums.size(); i++) {
                if (nums[i] == target) {
                    right = i;
                    continue;
                } else {
                    break;
                }
            }
            ans[1] = right;
            for (int i = point; i >= 0; i--) {
                if (nums[i] == target) {
                    left = i;
                    continue;
                } else {
                    break;
                }
            }
            ans[0] = left;
        }
        return ans;
    }
};

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        length = len(nums)
        left = 0
        right = length - 1
        point = 0
        flag = False
        ans = [-1, -1]
        while left <= right:
            middle = left + (right - left) // 2
            if target > nums[middle]:
                left = middle + 1
            elif target < nums[middle]:
                right = middle - 1
            else:
                ans[0] = ans[1] = middle
                flag = True
                break
        # while循环版
        if flag:
            while ans[1] < length - 1:
                if nums[ans[1] + 1] == target:
                    ans[1] += 1
                else:
                    break
            while ans[0] > 0:
                if nums[ans[0] - 1] == target:
                    ans[0] -= 1
                else:
                    break
        return ans

• 此种做法采用二分查找的思路找到一个目标值,然后向左右延伸(延伸的逻辑可以使用for循环或者while循环)
• 但如果想要更加直接的找到两个边界leftwall和rightwall,则需要仔细思考循环过程更新边界值的逻辑
  • 一个在二分查找中普遍的现象是left会不断向右,(如果没有在循环内部终止)直至大于right,right会不断向左,直至小于left
  • 则left和right终止的位置会在目标值的两侧,也就是未经处理的边界
  • 一个数组会有以下三种情况
    • 目标值大于或小于全体数据 ==> 对应的一侧leftwall或rightwall不被更新
    • 目标值在数组中没有出现 ==> leftwall或rightwall的差值小于1
    • 目标值出现 ==> leftwall或rightwall一个指向目标片段的前方,一个指向后方(不包含该元素)

class Solution {
private:
    int searchRightWall(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        int rightwall = -2;
        while (left <= right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle - 1;
            } else {
                left = middle + 1;
                rightwall = left;
            }
        }
        return rightwall;
    }
    int searchLeftWall(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        int leftwall = -2;
        while (left <= right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] >= target) {
                right = middle - 1;
                leftwall = right;
            } else {
                left = middle + 1;
            }
        }
        return leftwall;
    }

public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftwall = searchLeftWall(nums, target),
            rightwall = searchRightWall(nums, target);
        if (rightwall == -2 || leftwall == -2) {
            return {-1, -1};
        }
        if (rightwall - leftwall > 1) {
            return {leftwall + 1, rightwall - 1};
        }
        return {-1, -1};
    }
};

class Solution:
    def searchLeftWall(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1
        leftWall = -2
        while left <= right:
            middle = left + (right - left) // 2
            if nums[middle] >= target:
                right = middle - 1
                leftWall = right
            else:
                left = middle + 1
        return leftWall

    def searchRightWall(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1
        rightWall = -2
        while left <= right:
            middle = left + (right - left) // 2
            if nums[middle] > target:
                right = middle - 1
            else:
                left = middle + 1
                rightWall = left
        return rightWall

    def searchRange(self, nums: List[int], target: int) -> List[int]:
        leftWall = self.searchLeftWall(nums, target)
        rightWall = self.searchRightWall(nums, target)
        if leftWall == -2 or rightWall == -2:
            return [-1, -1]
        if rightWall - leftWall > 1:
            return [leftWall + 1, rightWall - 1]
        return [-1, -1]

• 注意使用self来调用类内部的方法 (如果不使用self来调用这些方法，那么它们将被视为全局函数，而不是类的方法。这将导致未定义的行为或错误。)

  • 在面向对象编程中，self是一个约定俗成的名称，用于表示对象自身。在类的方法中，self是必须的，它作为第一个参数传递给方法。通过使用self来调用方法，可以确保该方法是在对象上调用的。

• python可以在函数内部定义函数

  • 这种在函数内定义函数的方式称为嵌套函数（nested function）或内部函数（inner function）。
  • 嵌套函数的定义方式与普通函数类似，只是它们位于另一个函数的内部。
  • 嵌套函数可以访问外部函数的变量和参数，这是因为它们形成了一个闭包（closure）。

27. 移除元素

给你一个数组 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,3,0,4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

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

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == val) {
                int move_i = i;
                while (move_i < nums.size() - 1) {
                    nums[move_i] = nums[move_i + 1];
                    move_i++;
                }
                nums.pop_back();
                i = 0;
            }
        }
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == val) {
                int move_i = i;
                while (move_i < nums.size() - 1) {
                    nums[move_i] = nums[move_i + 1];
                    move_i++;
                }
                nums.pop_back();
                i = 0;
            }
        }
        return nums.size();
    }
};

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i = 0
        while i < len(nums):
            if nums[i] == val:
                nums.pop(i)
            i += 1
        i = 0
        while i < len(nums):
            if nums[i] == val:
                nums.pop(i)
            i += 1
        i = 0
        while i < len(nums):
            if nums[i] == val:
                nums.pop(i)
            i += 1
        return len(nums)

• 使用了一种非常暴力的办法,甚至可以说是愚蠢(在一次删除操作没有达成目标时,再次使用相同操作)
• 本质上是数组性质的深刻理解(数组的元素不能被直接删除,只能通过覆盖重写的方式实现删除的效果)
  • 库函数 ==> c++的vector中,如果使用了erase方法,则数组会被重排,size也会随之减小(并不是O(1)的操作,而是O(n)的操作,只是将下面的操作流程封装起来使用)
    • 关于库函数的使用:如果可以直接用库函数解决,那么就不要使用库函数,如果库函数只是我们实现算法的一小步,并且我们知道它的实现逻辑和时空复杂度,那么是可以使用的,同时也减少了出错的概率
  • 对于一般的数组而言(没有vector的特性),则需要移动后续元素到前面覆盖删除位置完成删除操作以保证数组数据的地址连续性

// 一种更加简洁的暴力算法
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int length = nums.size();
        for (int i = 0; i < length; i++) {
            if (nums[i] == val) {
                for (int j = i; j < length - 1; j++) {
                    nums[j] = nums[j + 1];
                }
                length--;
                i--;
            }
        }
        return length;
    }
};

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        length = len(nums)
        i = 0
        while i < length:
            if nums[i] == val:
                for j in range(i, length - 1):
                    nums[j] = nums[j + 1]
                length -= 1
                i -= 1
            i += 1
        return length

• 这里引入一种双指针的思路(后续有相应的章节)
  • 定义快慢指针,将旧数组和新数组关联起来
  • 当快指针指向的元素!=要删除元素时,更新慢指针指向的值为快指针指向的值,慢指针向后移动一次
    • 快慢指针只是在数组中存在要删除元素时,才会有快慢差异

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int fast = 0, slow = 0;
        for (; fast < nums.size(); fast++) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow; // 最后一跳使得慢指针指向最后一个元素的后面
    }
};

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        fast = slow = 0
        for fast in range(len(nums)):
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
        return slow

• python中还可以使用list的remove(元素)方法来实现该操作
  • remove方法的实现逻辑如下：
    1. 从列表的第一个元素开始遍历，直到找到第一个与element相等的元素。
    2. 找到相等的元素后，将其从列表中删除，并将后续元素向前移动，填补被删除元素的位置。
    3. 如果列表中存在多个与element相等的元素，remove方法只会删除第一个遇到的元素。
    4. 如果列表中不存在与element相等的元素，则会抛出ValueError异常。

26.删除排序数组中的重复项

给你一个 非严格递增排列 的数组 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 * 104
• -104 <= nums[i] <= 104
• nums 已按 非严格递增 排列

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 0, fast = 1;
        for (; fast < nums.size(); fast++) {
            if (nums[fast] != nums[slow]) {
                nums[slow + 1] = nums[fast];
                slow++;
            }
        }
        return slow + 1;
    }
};

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        fast = 1
        slow = 0
        for fast in range(1, len(nums)):
            if nums[fast] != nums[slow]:
                nums[slow + 1] = nums[fast]
                slow += 1
        return slow + 1

• 通过快慢指针的数值差异来建立新数组
  • 直到fast指向与slow不相等的值,才会把++slow对应的元素更新
  • 注意,slow在最后指向了一个不重复的元素,并没有指向新数组的最后一个元素的后面

283.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

提示:

• 1 <= nums.length <= 104
• -231 <= nums[i] <= 231 - 1

**进阶：**你能尽量减少完成的操作次数吗？

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int fast = 0, slow = 0;
        for (; fast < nums.size(); fast++) {
            if (nums[fast] != 0) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        for (int j = slow; j < nums.size(); j++) {
            nums[j] = 0;
        }
    }
};

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        fast = slow = 0
        for fast in range(len(nums)):
            if nums[fast] != 0:
                nums[slow] = nums[fast]
                slow += 1
        for i in range(slow, len(nums)):
            nums[i] = 0

• 没有什么特殊的技巧,使用了双指针
• 可以使用特殊的冒泡排序完成

844.比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

**注意：**如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

提示：

• 1 <= s.length, t.length <= 200
• s 和 t 只含有小写字母以及字符 '#'

• 栈方法(后续的章节里会展开)

// 使用栈
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        stack<char> sStack, tStack;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == '#') {
                if (!sStack.empty()) {
                    sStack.pop();
                }
            } else {
                sStack.push(s[i]);
            }
        }
        for (int i = 0; i < t.size(); i++) {
            if (t[i] == '#') {
                if (!tStack.empty()) {
                    tStack.pop();
                }
            } else {
                tStack.push(t[i]);
            }
        }
        if (sStack.size() != tStack.size()) {
            return false;
        } else {
            while (!sStack.empty()) {
                if (sStack.top() == tStack.top()) {
                    sStack.pop();
                    tStack.pop();
                    continue;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
};

• python中可以使用list这一数据结构以及相应的方法实现栈
  • pop(index)方法在不指定index时默认删除最后一个元素
  • append(element)方法可以向列表末尾追加一个元素
  • listname[-1]可以引用栈顶的元素(即末尾元素)
  • len()方法可以用来得到列表的长度(也可以判断列表是否为空)

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        sList = []
        tList = []
        for i in range(len(s)):
            if s[i] == "#":
                if len(sList):
                    sList.pop()
            else:
                sList.append(s[i])
        for i in range(len(t)):
            if t[i] == "#":
                if len(tList):
                    tList.pop()
            else:
                tList.append(t[i])
        if len(sList) != len(tList):
            return False
        else:
            while len(sList):
                if sList[-1] == tList[-1]:
                    sList.pop()
                    tList.pop()
                    continue
                else:
                    return False
        return True

• 双指针(不同数组内的快慢指针)

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int i = s.size() - 1, j = t.size() - 1; // 逆序遍历
        int skipS = 0, skipT = 0; // 未消耗的退格数目
        while (i >= 0 || j >= 0) {
            // 寻找s的一个合法字符
            while (i >= 0) {
                if (s[i] == '#') {
                    skipS++, i--;
                } else if (skipS > 0) {
                    skipS--, i--;
                } else {
                    break;
                }
            } 
            // 寻找t的一个合法字符
            while (j >= 0) {
                if (t[j] == '#') {
                    skipT++, j--;
                } else if (skipT > 0) {
                    skipT--, j--;
                } else {
                    break;
                }
            }
            // 判断是否相等
            if (i >= 0 && j >= 0) {
                if (s[i] != t[j]) {
                    return false;
                }
            } else {
                if (i >= 0 || j >= 0) { //有至少一个指针已经指向了字符串之外(长度不一)
                    return false;
                }
            }
            i--, j--;
        }
        return true;
    }
};

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        i = len(s) - 1
        j = len(t) - 1
        skipS = 0
        skipT = 0
        while i >= 0 or j >= 0:
            while i >= 0:
                if s[i] == "#":
                    skipS += 1
                    i -= 1
                elif skipS > 0:
                    skipS -= 1
                    i -= 1
                else:
                    break
            while j >= 0:
                if t[j] == "#":
                    skipT += 1
                    j -= 1
                elif skipT > 0:
                    skipT -= 1
                    j -= 1
                else:
                    break
            if i >= 0 and j >= 0:
                if s[i] != t[j]:
                    return False
            else:
                if i >= 0 or j >= 0:
                    return False
            i -= 1
            j -= 1
        return True

977.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

进阶：

• 请你设计时间复杂度为 O(n) 的算法解决本问题

• 暴力做法(直接平方+排序)
  • python中list的sort()方法的一些参数
    • key：指定一个函数来用作排序的关键字。默认值为None，表示使用元素自身进行比较。如果指定了key参数，sort()方法将使用该函数的返回值进行排序。
    • reverse：指定排序顺序。默认值为False，表示升序排序。如果将reverse设置为True，则进行降序排序。
  • c++中algorithm头文件下std::sort()函数的一些参数
    • first 和 last：指定排序范围的首元素和尾元素的迭代器。排序将从 first 开始，直到 last 的前一个元素。
      • 注意是迭代器,对于vector或者string排序要使用相应的迭代器;对一般数组排序使用地址即可
    • comp（可选）：指定一个自定义的比较函数，用于确定元素的顺序。默认情况下，使用 < 运算符进行比较。比较函数应该接受两个参数，并返回一个布尔值，表示第一个参数是否小于第二个参数。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i];
        }
        sort(nums.begin(), nums.end());
        return nums;
    }
};

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] = nums[i] * nums[i]
        nums.sort()
        return nums

• 双指针做法

// 其实是三个指针
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int leftptr = 0, rightptr = nums.size() - 1;
        int newptr = rightptr;
        vector<int> output(nums.size(), 0);
        while (leftptr <= rightptr) {
            int a = nums[leftptr] * nums[leftptr],
                b = nums[rightptr] * nums[rightptr];
            if (a >= b) {
                output[newptr] = a;
                leftptr++;
            } else {
                output[newptr] = b;
                rightptr--;
            }
            newptr--;
        }
        return output;
    }
};

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        output = [0] * len(nums)
        leftptr = 0
        newptr = rightptr = len(nums) - 1
        # 提前计算出来会减少重复的计算
        for i in range(len(nums)):
            nums[i] = nums[i] ** 2
        while leftptr <= rightptr:
            if nums[leftptr] >= nums[rightptr]:
                output[newptr] = nums[leftptr]
                leftptr += 1
            else:
                output[newptr] = nums[rightptr]
                rightptr -= 1
            newptr -= 1
        return output

• python版本中如果你使用了output = nums这样的语句,则output只是对nums的一个新的引用,对于nums的修改会反映到output上

  • 在 Python 中，变量不直接存储值本身，而是存储对值的引用。这意味着当你创建一个变量时，你实际上是在创建一个指向内存中某个对象的指针。这种行为在处理可变对象（如列表、字典、集合等）时尤其重要，因为如果你有多个引用指向同一个可变对象，通过一个引用对对象的修改会影响到所有引用。

    引用：

    当你将一个变量赋值给另一个变量时，你只是在创建新的引用到原始对象。例如：

    a = [1, 2, 3] # 创建一个列表 [1, 2, 3]
    b = a         # b 是对同一个列表的新引用
    

    在这个例子中，a 和 b 都引用相同的列表。如果你修改了 b（比如 b.append(4)），a 也会变化，因为它们指向的是同一个对象。

    创建副本：

    有时候，你可能不想要两个变量指向同一个对象，而是想要它们各自有自己的独立对象。这时候，你就需要创建一个副本。对于列表，你可以使用多种方法创建副本：

    a = [1, 2, 3]    # 创建一个列表 [1, 2, 3]
    b = a[:]          # 使用切片操作创建 a 的一个副本
    c = list(a)       # 使用 list 构造函数创建 a 的一个副本
    d = a.copy()      # 使用列表的 copy 方法创建 a 的一个副本
    

    在这个例子中，b、c 和 d 是 a 的副本，它们具有相同的内容，但是是独立的对象。现在，如果你修改 b、c 或 d，a 将不会受到影响，因为它们不再指向同一个对象。

    对于其他可变数据类型，如字典和集合，你也可以使用相应的 copy() 方法或相应的构造函数来创建副本。

    深拷贝与浅拷贝：

    当对象中还包含其他对象时（例如，列表中的列表），光复制顶层对象可能不够。创建副本的方法（如切片、list() 构造函数、copy() 方法）只进行浅拷贝，即只复制对象本身和其中的直接子对象的引用，而不复制子对象本身。

    如果你需要一个完全独立的副本，其中包含的所有子对象也都是独立的副本，你需要进行深拷贝。在 Python 中，你可以使用 copy 模块的 deepcopy() 函数来实现：

    import copy
    a = [[1, 2], [3, 4]]
    b = copy.deepcopy(a)  # 创建 a 的深拷贝
    

    现在，b 是 a 的一个深拷贝，所以你可以独立地修改 b 中的子列表，而不会影响 a。

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

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

示例 3：

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

提示：

• 1 <= target <= 109
• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

• 暴力解法,遇到特别大的数据规模会超时
  • 时间复杂度:O(n^2)
  • 空间复杂度:O(1)

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int length = nums.size();
        bool flag = false;
        for (int i = 0; i < nums.size(); i++) {
            int sum = 0;
            for (int j = i; j < nums.size(); j++) {
                sum += nums[j];
                if (sum >= target) {
                    flag = true;
                    length = min(j - i + 1, length);
                    break;
                }
            }
        }
        if (flag) {
            return length;
        } else {
            return 0;
        }
    }
};

• 前缀和做法,依然超时,但是已经开了一个好头(减去了重复的和计算)
  • 时间复杂度:O(n^2)
  • 空间复杂度:O(n)

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        vector<unsigned long long int> sNums(n, 0);
        unsigned long long sum{0};
        for (int i = 0; i < n; i++) {
            sum += nums[i];
            sNums[i] = sum;
        }
        if (sum < target) {
            return 0;
        } else {
            int length = n;
            for (int j = n - 1; j >= 0; j--) {
                for (int k = j; k >= 0; k--) {
                    if (sNums[j] - sNums[k] >= target) {
                        length = min(length, j - k);
                    }
                }
            }
            return length;
        }
    }
};

• 滑动窗口(双指针)+前缀和(可以被优化,这里便于理解)
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        vector<unsigned long long int> sNums(n + 1, 0);
        unsigned long long sum{0};
        for (int i = 0; i < n; i++) {
            sum += nums[i];
            sNums[i + 1] = sum;
        }
        if (sum < target) {
            return 0;
        }
        int lPtr = 0, rPtr = 1;
        // rPtr是窗口的右端点,主动更新
        // lPtr是窗口的左端点,被动更新
        int ans = n;
        bool flag = false;
        for (; rPtr <= n; rPtr++) {
            while (sNums[rPtr] - sNums[lPtr] >= target) {
                flag = true;
                lPtr++;
                ans = min(rPtr - lPtr + 1, ans);
            }
        }
        if (flag) {
            return ans;
        } else {
            return 0;
        }
    }
};

# 优化了连续子序列和的计算方式(有点像"忒修斯之船")
class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        ans = len(nums)
        lPtr = 0
        sNum = 0
        flag = False
        for rPtr in range(0, len(nums)):
            sNum += nums[rPtr]
            while sNum >= target:
                flag = True
                ans = min(rPtr - lPtr + 1, ans)
                sNum -= nums[lPtr]
                lPtr += 1
        if flag:
            return ans
        else:
            return 0

第二章 链表

第三章 哈希表

第四章 字符串

第五章 双指针法

第六章 栈与队列

第七章 二叉树

第八章 回溯算法

第九章 贪心算法

第十章 动态规划

第十一章 单调栈

第十二章 图论