打卡记录 on 木人的CS学习笔记

代码随想录打卡第31天 | 56. 合并区间、738. 单调递增的数字、968. 监控二叉树

Fri, 03 Apr 2026 00:00:00 +0000

56. 合并区间

链接：56. 合并区间
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

区间判重，更新 end；

看完题解后的想法

–

实现中遇到的困难

–

代码

class Solution {
public:
 vector<vector<int>> merge(vector<vector<int>>& intervals) {
 sort(intervals.begin(), intervals.end()); // 核心，先排序
 int start = intervals[0][0];
 int end = intervals[0][1];
 vector<vector<int>> res;

 for (int i = 1; i < (int)intervals.size(); i++) {
 int left = intervals[i][0];
 int right = intervals[i][1];

 if (left <= end) {
 if (right > end) {
 end = right;
 } else {
 continue;
 }
 } else {
 res.push_back({start, end});
 start = left;
 end = right;
 }
 }
 // 最后一组元素需要手动push
 res.push_back({start, end});
 return res;
 }
};

738. 单调递增的数字

链接：738. 单调递增的数字
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

第一想法是拿个 vector 把数字都装起来，但是之后怎么做不明白；

代码随想录打卡第30天 | 452. 用最少数量的箭引爆气球、435. 无重叠区间、763. 划分字母区间

Thu, 02 Apr 2026 00:00:00 +0000

452. 用最少数量的箭引爆气球

链接：452. 用最少数量的箭引爆气球
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

不断地调整起点和终点范围，如果任意一边（其实是起点，排序之后有序）在范围内，就可以被引爆；

注意如果终点也在范围内就要调整终点位置；

看完题解后的想法

–

实现中遇到的困难

–

代码

class Solution {
public:
 int findMinArrowShots(vector<vector<int>>& points) {
 sort(points.begin(), points.end());
 int sum = 1;
 int start = points[0][0];
 int end = points[0][1];
 for (int i = 1; i < points.size(); i++) {
 if (points[i][0] <= end) {
 start = points[i][0];
 if (points[i][1] <= end) {
 end = points[i][1];
 }
 } else {
 start = points[i][0];
 end = points[i][1];
 sum++;
 }
 }

 return sum;
 }
};

435. 无重叠区间

链接：435. 无重叠区间
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

跟 LC452 挺像的；

代码随想录打卡第29天 | 134. 加油站、135. 分发糖果、860. 柠檬水找零、406. 根据身高重建队列

Wed, 01 Apr 2026 00:00:00 +0000

134. 加油站

链接：134. 加油站
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

没想出来；

看完题解后的想法

很巧妙，其实是思维盲区；

既然总油量大于等于总消耗有解，那么只要找到开始盈余的部分，这样剩下的油总能够支持消耗；

这里很巧妙，因为如果总量只要是大于等于，那不管前面亏了多少，后面一定剩了多少，只要不断舍去亏损的位置就行了；

和 LC53 是一个思想；

实现中遇到的困难

–

代码

class Solution {
public:
 int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
 int totalDiff = 0;
 int curDiff = 0;
 int start = 0;
 // 1. 如果总油量小于总消耗，不可能跑完
 // 2. 既然总油量大于等于总消耗有解，那么就要找到开始盈余的部分，这样才能支撑跑完全程
 for (int i = 0; i < gas.size(); i++) {
 totalDiff += gas[i] - cost[i];
 curDiff += gas[i] - cost[i];
 if (curDiff < 0) {
 start = i + 1;
 curDiff = 0;
 }
 }

 return totalDiff >= 0 ? start : -1;
 }
};

135. 分发糖果

链接：135. 分发糖果
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

没啥思路；

代码随想录打卡第28天 | 122. 买卖股票的最佳时机II、55. 跳跃游戏、45. 跳跃游戏II、1005. K次取反后最大化的数组和

Tue, 31 Mar 2026 00:00:00 +0000

122. 买卖股票的最佳时机II

链接：122. 买卖股票的最佳时机II
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

连续上涨的利润等于每天差价之和

看完题解后的想法

–

实现中遇到的困难

–

代码

class Solution {
public:
 int maxProfit(vector<int>& prices) {
 int profit = 0;
 for (int i = 1; i < prices.size(); i++) {
 // 只要后一天的股价高于前一天的股价就可以买进卖出，这样一定获利
 // 多次交易只是把一段长的收入拆分成了几段小的
 if (prices[i] > prices[i - 1]) {
 profit += prices[i] - prices[i-1];
 }
 }
 return profit;
 }
};

55. 跳跃游戏

链接：55. 跳跃游戏
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

最开始在思考如何到达右边，然后写了一串复杂的判断；

看完题解后的想法

要点不是能不能过去，而是中间会不会断

那么如果某个点的坐标大于了之前所有点的坐标+跨度，就说明这个点到达不了，就断了

所以要维护一个 最大可达坐标

实现中遇到的困难

–

代码

class Solution {
public:
 bool canJump(vector<int>& nums) {
 int maxReach = 0;
 for (int i = 0; i < nums.size(); i++) {
 // 如果当前最大可达坐标小于当前index，说明过不来，错误
 if (i > maxReach) {
 return false;
 }
 // 更新当前最大可达坐标，这里的作用就是在这个点之后的点的跨度如果小于该点，也在该点的包括范围内
 maxReach = max(maxReach, nums[i] + i);
 if (maxReach >= nums.size() - 1) {
 return true;
 }
 }

 return false;
 }
};

45. 跳跃游戏II

链接：45. 跳跃游戏II
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

可跳区域的左右是否夹了一个更大的可以跳出这个区域的点，如果有就说明可以去这个点，跳到更远的地方；

代码随想录打卡第27天 | 455. 分发饼干、376. 摆动序列、53. 最大子序和

Mon, 30 Mar 2026 00:00:00 +0000

贪心算法理论基础

贪心算法没有固定套路，本质就是选择每一阶段的局部最优，从而达到全局最优。

文章：代码随想录 - 贪心算法理论基础

455. 分发饼干

链接：455. 分发饼干
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

始终用最小可满足的条件去满足匹配；

整体复杂度由排序主导；

看完题解后的想法

–

实现中遇到的困难

–

代码

class Solution {
public:
 int findContentChildren(vector<int>& g, vector<int>& s) {
 // 排序后贪心
 sort(g.begin(), g.end());
 sort(s.begin(), s.end());
 int index = 0;
 int res = 0;

 for (int i = 0; i < g.size(); i++) {
 while (index < s.size() && s[index] < g[i]) {
 index++; // 无法满足，skip
 }
 if (index < s.size()) {
 // 满足条件且index合法，分配
 res++;
 index++; // 分配之后也要前进
 }
 }

 return res;
 }
};

376. 摆动序列

链接：376. 摆动序列
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

遍历序列，找到每一个拐点；但是很难说清楚为什么这就是最长的；

代码随想录打卡第25天 | 491. 递增子序列、46. 全排列、47. 全排列II、51. N皇后、37. 解数独

Sat, 28 Mar 2026 00:00:00 +0000

491. 递增子序列

链接：491. 递增子序列
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

这题不能排序，同层去重又不会了；

看完题解后的想法

使用 set 记录本层使用过的数据，这是更加一般的同层去重；

实现中遇到的困难

不会非排序的同层去重；

代码

class Solution {
public:
 vector<vector<int>> res;
 vector<int> path;
 void backtracking(vector<int>& nums, int index) {
 if (path.size() >= 2) {
 res.push_back(path);
 }

 unordered_set<int> used; // 每层一个，记录本层用过的值
 for (int i = index; i < nums.size(); i++) {
 if ((!path.empty() && nums[i] < path.back()) || used.count(nums[i])) {
 continue;
 }
 used.insert(nums[i]); // 注意退栈不用 erase，因为还在当前层
 path.push_back(nums[i]);
 backtracking(nums, i+1);
 path.pop_back();
 }
 }

 vector<vector<int>> findSubsequences(vector<int>& nums) {
 backtracking(nums, 0);
 return res;
 }
};

46. 全排列

链接：46. 全排列
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

排列不需要传入 index，因为每次都是从头访问；

代码随想录打卡第24天 | 93. 复原IP地址、78. 子集、90. 子集II

Fri, 27 Mar 2026 00:00:00 +0000

93. 复原IP地址

链接：93. 复原IP地址
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

和分割回文串类似，不是去构造一个合法的子串，而是去直接分割，不合法就 skip；

看完题解后的想法

–

实现中遇到的困难

最开始 path 是一个 str，对于 IP 地址要求的四段判断比较复杂；

path 在这里也需要是 vector，这样回溯才方便；最后直接构造一个返回字符串就行；

代码

class Solution {
public:
 bool isValid(string& s) {
 if (s.size() > 1 && s[0] == '0') return false;
 if (stoi(s) > 255) return false;
 return true;
 }
 vector<string> res;
 vector<string> path;
 void backtracking(string s, int index) {
 if (path.size() == 4) {
 if (index == s.size()) {
 res.push_back(path[0] + "." + path[1] + "." + path[2] + "." + path[3]);
 }
 return; // 不管是否收集，4段了就不再递归
 }

 for (int i = index; i < s.size() && i - index < 3; i++) {
 string str = s.substr(index, i - index + 1);
 if (isValid(str)) {
 path.push_back(str);
 backtracking(s, i+1);
 path.pop_back();
 } else {
 break; // 当前不合法后面更长也不合法
 }
 }
 }
 vector<string> restoreIpAddresses(string s) {
 if (s.size() > 12 || s.size() < 4) {
 return res;
 }
 backtracking(s, 0);
 return res;
 }
};

78. 子集

链接：78. 子集
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

自己做的时候考虑到符合条件的子集大小是变动的，就在回溯外面套了一个 while 循环去增加 size；

代码随想录打卡第23天 | 39. 组合总和、40. 组合总和II、131. 分割回文串

Thu, 26 Mar 2026 00:00:00 +0000

39. 组合总和

链接：39. 组合总和
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

回溯三部曲；

看完题解后的想法

可以用排序加速剪枝；

实现中遇到的困难

–

代码

class Solution {
public:
 vector<vector<int>> res;
 vector<int> path;
 void backtracking(vector<int>& candidates, int target, int index, int sum) {
 if (sum == target) {
 res.push_back(path);
 return;
 }

 for (int i = index; i < candidates.size() && sum + candidates[i] <= target; i++) {
 sum += candidates[i];
 path.push_back(candidates[i]);
 backtracking(candidates, target, i, sum);
 sum -= candidates[i];
 path.pop_back();
 }
 }
 vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
 sort(candidates.begin(), candidates.end());
 backtracking(candidates, target, 0, 0);
 return res;
 }
};

40. 组合总和II

链接：40. 组合总和II
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

依旧回溯三部曲，但是注意同层去重逻辑；

代码随想录打卡第22天 | 77. 组合、216. 组合总和III、17. 电话号码的字母组合

Wed, 25 Mar 2026 00:00:00 +0000

回溯算法理论基础

文章：代码随想录 - 回溯算法理论基础
视频：B站讲解

77. 组合

链接：77. 组合
文章：代码随想录
视频：B站讲解
剪枝：B站讲解
状态：❌

第一想法

第一想法是回溯，但是对于如何存 path，如何回溯有点摸不着头脑;

看完题解后的想法

不用复杂的递归返回，只把递归作为前进的路径，直接使用外部空间保存路径;

外部空间必须在退出递归时 pop 数据，这就是回溯;

实现中遇到的困难

剪枝条件写起来很复杂，但是搞清楚了如何剪枝就能马上写出来;

代码

class Solution {
public:
 /*
 回溯的模板可以这样理解：
 1. 路径 (path)：当前已经选了哪些数
 2. 选择列表：从 start 到 n，还能选哪些数
 3. 结束条件：path.size() == k 时，收集结果
 */
 vector<vector<int>> res;
 vector<int> path;
 void backtracking(int n, int k, int start) {
 // 返回条件：找到k个数
 if (path.size() == k) {
 res.push_back(path);
 return;
 }

 /*
 剪枝优化：
 当前已有数字 path.size() 个, 还需数字 k - path.size() 个
 在 i 到 n 之间有 n - i + 1个数字
 n - i + 1 >= k - path.size()
 */
 for (int i = start; i <= n + 1 + path.size() - k; i++) {
 path.push_back(i);
 backtracking(n, k, i + 1);
 path.pop_back();
 }
 }
 vector<vector<int>> combine(int n, int k) {
 backtracking(n, k, 1);
 return res;
 }
};

216. 组合总和III

链接：216. 组合总和III
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

回溯三部曲：

代码随想录打卡第21天 | 669. 修剪二叉搜索树、108. 将有序数组转换为二叉搜索树、538. 把二叉搜索树转换为累加树

Tue, 24 Mar 2026 00:00:00 +0000

669. 修剪二叉搜索树

链接：669. 修剪二叉搜索树
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

在小于low的节点，节点和左树全部抛掉，返回右树（如果右树不存在一样返回）；

大于high的节点，节点和右树全部抛掉，返回左树（如果左树不存在一样返回）；

看完题解后的想法

要学会运用返回节点简化操作，这题和LC450类似，都是用返回节点简化了左右判断，因为BST自带左右；

实现中遇到的困难

–

代码

class Solution {
public:
 TreeNode* trimBST(TreeNode* root, int low, int high) {
 if (!root) return nullptr;

 if (root->val < low) {
 return trimBST(root->right, low, high);
 }
 if (root->val > high) {
 return trimBST(root->left, low, high);
 }

 root->left = trimBST(root->left, low, high);
 root->right = trimBST(root->right, low, high);

 return root;
 }
};

108. 将有序数组转换为二叉搜索树

第一想法

不断取中点构造二叉树;

代码随想录打卡第20天 | 235. 二叉搜索树的最近公共祖先、701. 二叉搜索树中的插入操作、450. 删除二叉搜索树中的节点

Mon, 23 Mar 2026 00:00:00 +0000

235. 二叉搜索树的最近公共祖先

链接：235. 二叉搜索树的最近公共祖先
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

利用二叉搜索树的性质，可以用数值大小确定子树，第一次遇到的在 [p, q] 或者 [q, p] 间的数，就是最近公共祖先；

BST 中，对于当前节点 cur，有三种情况：

情况一：cur 的值比 p 和 q 都大。说明 p 和 q 都在 cur 的左子树里，公共祖先一定在左边，cur 不是答案。
情况二：cur 的值比 p 和 q 都小。同理，都在右子树，往右走。
情况三：cur 的值在 p 和 q 之间（含等于）。这时候只有两种可能：

p 和 q 分别在 cur 的左右子树 → cur 就是公共祖先

cur 本身就是 p 或 q 中的一个，另一个在它的子树里 → cur 也是公共祖先

看完题解后的想法

–

实现中遇到的困难

需要确定 p 和 q 的大小关系；

代码

class Solution {
public:
 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
 if (p->val > q->val) swap(p, q);
 TreeNode* cur = root;
 while (cur) {
 if (cur->val >= p->val && cur->val <= q->val) {
 return cur;
 } else if (cur->val < p->val) {
 cur = cur->right;
 } else {
 cur = cur->left;
 }
 }
 return nullptr;
 }
};

701. 二叉搜索树中的插入操作

链接：701. 二叉搜索树中的插入操作
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

二叉搜索树，可以直接比大小前进；然后找到空位就可以插进去了；

代码随想录打卡第18天 | 530. 二叉搜索树的最小绝对差、501. 二叉搜索树中的众数、236. 二叉树的最近公共祖先

Sat, 21 Mar 2026 00:00:00 +0000

530. 二叉搜索树的最小绝对差

链接：530. 二叉搜索树的最小绝对差
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

中序遍历是有序的，直接用当前减过去；

看完题解后的想法

–

实现中遇到的困难

需要对最左节点进行一个特判，因为最左节点没有可以相减的；

代码

class Solution {
public:
 int res = INT_MAX;
 int prev = -1; // -1 表示还没访问过任何节点

 void dfs(TreeNode* root) {
 if (!root) return;

 dfs(root->left);

 if (prev != -1) {
 res = min(res, root->val - prev); // BST中序是升序，不需要abs
 }
 prev = root->val;

 dfs(root->right);
 }

 int getMinimumDifference(TreeNode* root) {
 dfs(root);
 return res;
 }
};

501. 二叉搜索树中的众数

链接：501. 二叉搜索树中的众数
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

遍历+哈希，直接在递归中怎么做不知道；

代码随想录打卡第17天 | 654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树

Fri, 20 Mar 2026 00:00:00 +0000

654. 最大二叉树

链接：654. 最大二叉树
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

和LC105, 106一样, 但是逻辑更加简单,直接采用传index;

看完题解后的想法

–

实现中遇到的困难

注意index是全局index所以直接传

代码

class Solution {
public:
 TreeNode* recurse(vector<int>& nums, int begin, int end) {
 if (begin == end) return nullptr;

 // 1. 找到max值和index，这就是root
 int indexRoot = begin;
 for (int i = begin; i < end; i++) {
 if (nums[i] > nums[indexRoot]) {
 indexRoot = i;
 }
 }
 TreeNode* root = new TreeNode(nums[indexRoot]);

 // 2. 挂树+直接传index做分组，注意index是全局index所以直接传
 root->left = recurse(nums, begin, indexRoot);
 root->right = recurse(nums, indexRoot+1, end);

 return root;
 }
 TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
 return recurse(nums, 0, (int)nums.size());
 }
};

617. 合并二叉树

链接：617. 合并二叉树
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

使用递归，返回 root1 ，只要 root1 没有某棵树，就挂上 root2 的；

代码随想录打卡第16天 | 513. 找树左下角的值、112. 路径总和、113. 路径总和II、106. 从中序与后序遍历序列构造二叉树、105. 从前序与中序遍历序列构造二叉树

Thu, 19 Mar 2026 00:00:00 +0000

513. 找树左下角的值

链接：513. 找树左下角的值
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

层序遍历，每层的第一个值

看完题解后的想法

实现中遇到的困难

代码

class Solution {
public:
 int findBottomLeftValue(TreeNode* root) {
 int res;
 if (!root) {
 return res;
 }
 queue<TreeNode*> q;
 q.push(root);

 while (!q.empty()) {
 int num = q.size();
 for (int i = 0; i < num; i++) {
 TreeNode* cur = q.front();
 q.pop();
 if (i == 0) {
 res = cur->val;
 }

 if (cur->left) {
 q.push(cur->left);
 }
 if (cur->right) {
 q.push(cur->right);
 }
 }
 }

 return res;
 }
};

112. 路径总和

链接：112. 路径总和
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

DFS+回溯；栈自带回溯；

代码随想录打卡第15天 | 110. 平衡二叉树、257. 二叉树的所有路径、404. 左叶子之和、222. 完全二叉树的节点个数

Wed, 18 Mar 2026 00:00:00 +0000

110. 平衡二叉树

链接：110. 平衡二叉树
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

没想出来;

看完题解后的想法

从底到顶递归算高度,很巧妙;

对于底层叶子往上递归的过程需要理解;

实现中遇到的困难

代码

class Solution {
public:
 bool isBalanced(TreeNode* root) {
 return getHigh(root) != -1;
 }

 int getHigh(TreeNode* root) {
 // 1. 递归到底之后返回 0
 if (!root) {
 return 0;
 }

 // 2. 左子树高度
 int left = getHigh(root->left);
 if (left == -1) return -1;
 // 3. 右子树高度
 int right = getHigh(root->right);
 if (right == -1) return -1;

 if (abs(left - right) > 1) {
 return -1;
 }

 // 4. 返回当前高度,注意因为叶子节点的左右子树都是 nullptr 返回了 0,高度为 1
 return 1 + max(left, right);
 }
};

257. 二叉树的所有路径

链接：257. 二叉树的所有路径
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

使用递归，一层加一个路径；

代码随想录打卡第14天 | 226. 翻转二叉树、101. 对称二叉树、104. 二叉树的最大深度、111. 二叉树的最小深度

Tue, 17 Mar 2026 00:00:00 +0000

226. 翻转二叉树

链接：226. 翻转二叉树
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

遍历节点，然后交换节点的左右子树，DFS和BFS都能做；

看完题解后的想法

注意中序遍历因为是 左-根-右 ，在根节点交换完之后要继续访问左子树，因为已经交换了；

实现中遇到的困难

中序和后序的迭代写法还是记不牢；

代码

前序递归解：

class Solution {
public:
 TreeNode* invertTree(TreeNode* root) {
 dfs(root);
 return root;
 }

 void dfs(TreeNode* root) {
 if (!root) return;

 TreeNode* tmp = root->right;
 root->right = root->left;
 root->left = tmp;

 dfs(root->left);
 dfs(root->right);
 }
};

中序递归解：

class Solution {
public:
 TreeNode* invertTree(TreeNode* root) {
 dfs(root);
 return root;
 }

 void dfs(TreeNode* root) {
 if (!root) return;

 dfs(root->left);
 TreeNode* tmp = root->right;
 root->right = root->left;
 root->left = tmp;
 dfs(root->left); // 交换左右所以记得继续走左
 }
};

前序迭代：

代码随想录打卡第13天 | 二叉树理论基础、递归遍历、迭代遍历、层序遍历十题

Mon, 16 Mar 2026 00:00:00 +0000

需要了解二叉树的种类，存储方式，遍历方式以及二叉树的定义。

文章：代码随想录 - 二叉树理论基础

DFS

144. 二叉树的前序遍历

链接：144. 二叉树的前序遍历
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

根 - 左 - 右

可以递归dfs，还可以迭代用栈模拟，还可以用Morris，但是Morris太复杂了；

看完题解后的想法

前序是"根-左-右"，弹出就访问，访问完把左右子节点压栈。节点被弹出只有一种含义：该访问了。不存在"我还要回来"的情况。

实现中遇到的困难

注意压栈的顺序是后访问的先压;

代码

递归解：(爆栈风险)

class Solution {
public:
 vector<int> preorderTraversal(TreeNode* root) {
 vector<int> res;
 dfs(root, res);
 return res;
 }

 void dfs(TreeNode* root, vector<int>& res) {
 if (root == nullptr) {
 return ;
 }
 res.push_back(root->val);
 dfs(root->left, res);
 dfs(root->right, res);
 }
};

迭代解：(面试要求)

class Solution {
public:
 vector<int> preorderTraversal(TreeNode* root) {
 vector<int> res;
 if (!root) {
 return res;
 }
 stack<TreeNode*> st;
 st.push(root);

 while (!st.empty()) {
 TreeNode* cur = st.top();
 st.pop();

 res.push_back(cur->val);
 // 先压后访问的
 if (cur->right) {
 st.push(cur->right);
 }
 // 再压先访问的
 if (cur->left) {
 st.push(cur->left);
 }
 }
 return res;
 }
};

145. 二叉树的后序遍历

链接：145. 二叉树的后序遍历
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

左 - 右 - 根, 迭代解不会;

代码随想录打卡第11天 | 150. 逆波兰表达式求值、239. 滑动窗口最大值、347. 前K个高频元素

Sat, 14 Mar 2026 00:00:00 +0000

150. 逆波兰表达式求值

链接：150. 逆波兰表达式求值
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

逆波兰表达式

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

看完题解后的想法

——

实现中遇到的困难

注意第一次出栈的是右操作数，第二次出栈的是左操作数；

代码

class Solution {
public:
 int evalRPN(vector<string>& tokens) {
 stack<int> st;

 for (string& t : tokens) {
 if (t == "+" || t == "-" || t == "*" || t == "/") {
 int a = st.top();
 st.pop();
 int b = st.top();
 st.pop();
 if (t == "+") {
 st.push(b + a);
 } else if (t == "-") {
 st.push(b - a);
 } else if (t == "*") {
 st.push(b * a);
 } else {
 st.push(b / a);
 }
 } else {
 st.push(stoll(t));
 }
 }

 return st.top();
 }
};

239. 滑动窗口最大值

链接：239. 滑动窗口最大值
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

老员工比新员工菜就优化，老员工大于35也优化

代码随想录打卡第10天 | 232. 用栈实现队列、225. 用队列实现栈、20. 有效的括号、1047. 删除字符串中的所有相邻重复项

Fri, 13 Mar 2026 00:00:00 +0000

232. 用栈实现队列

链接：232. 用栈实现队列
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

一个栈 s1 用来入队，一个栈 s2 用来出队；

看完题解后的想法

最开始每次把数据从 s1 倒入 s2 还要把 s2 中的数据倒回去，为了保持顺序一致；

但是其实可以做一个简化，只有s2中空了才从s1中补充，这样其实是分段连续的；

实现中遇到的困难

——

代码

class MyQueue {
public:
 MyQueue() {

 }

 void push(int x) {
 s1.push(x);
 }

 int pop() {
 transfer();
 int res = s2.top();
 s2.pop();

 return res;
 }

 int peek() {
 transfer();
 int res = s2.top();

 return res;
 }

 bool empty() {
 return s1.empty() && s2.empty();
 }
private:
 stack<int> s1;
 stack<int> s2;

 void transfer() {
 if (s2.empty()) {
 while (!s1.empty()) {
 s2.push(s1.top());
 s1.pop();
 }
 }
 }
};

225. 用队列实现栈

链接：225. 用队列实现栈
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

刚开始用两个queue互相捣腾数据；

代码随想录打卡第9天 | 151. 翻转字符串里的单词、55. 右旋字符串、28. 实现strStr()、459. 重复的子字符串

Thu, 12 Mar 2026 00:00:00 +0000

151. 翻转字符串里的单词

链接：151. 翻转字符串里的单词
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

第一想法感觉这道题好麻烦，然后拆解任务一共三步：

去掉两端以及中见多余的空格
翻转整个字符串
挨着翻转每个单词

其中在挨着翻转每个单词的时候因为尾端没有空格，所以临时加上一个空格在翻转完之后再去掉，避免了尾处理；

看完题解后的想法

原地去空格使用双指针法，最后需要resize，注意使用的size就是slow最后停留的index；

实现中遇到的困难

——

代码

class Solution {
public:
 string reverseWords(string s) {
 endSpace(s);
 reverse(s, 0, (int)s.size()-1);

 int left = 0;
 int right = 0;
 while (right <= (int)s.size()) {
 if (right == (int)s.size() || s[right] == ' ') {
 reverse(s, left, right-1);
 left = ++right;
 } else {
 right++;
 }
 }

 return s;
 }

 // 去掉两端以及中见多余的空格
 void endSpace(string& s) {
 int slow = 0;
 for (int fast = 0; fast < (int)s.size(); fast++) {
 if (s[fast] != ' ') {
 if (slow > 0) {
 s[slow++] = ' ';
 }
 while (fast < (int)s.size() && s[fast] != ' ') {
 s[slow++] = s[fast++];
 }
 }
 }
 s.resize(slow);
 }

 // 翻转函数
 void reverse(string& s, int left, int right) {
 int l = left;
 int r = right;

 while (l < r) {
 char tmp = s[r];
 s[r] = s[l];
 s[l] = tmp;
 l++;
 r--;
 }
 }
};

KamaCoder 55. 右旋字符串

链接：KamaCoder 55. 右旋字符串
文章：代码随想录
视频：无
状态：⚠️

第一想法

刚开始是准备整体移动+栈来构造新的字符串；

代码随想录打卡第8天 | 344. 反转字符串、541. 反转字符串II、54. 替换数字

Wed, 11 Mar 2026 00:00:00 +0000

344. 反转字符串

链接：344. 反转字符串
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

双指针法

看完题解后的想法

——

实现中遇到的困难

——

代码

class Solution {
public:
 void reverseString(vector<char>& s) {
 int n = s.size();
 int left = 0, right = n - 1;

 while (left < right) {
 char tmp = s[left];
 s[left] = s[right];
 s[right] = tmp;
 left++;
 right--;
 }
 }
};

541. 反转字符串II

链接：541. 反转字符串II
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

反转字符串写成可传位置的函数，然后一段段翻转，最后处理尾巴；

看完题解后的想法

用 for 循环每次跳 2k 更简洁；

实现中遇到的困难

——

代码

class Solution {
public:
 string reverseStr(string s, int k) {
 int n = s.size();
 int time = n / (2* k);
 int tail = n % (2* k);
 int index = 0;

 while (time > 0) {
 swapStr(s, index, index+k-1);
 index = index + 2 * k ;
 time--;
 }

 if (tail > 0 && tail < k) {
 swapStr(s, index, index+tail-1);
 } else {
 swapStr(s, index, index+k-1);
 }

 return s;
 }

 void swapStr(string& s, int l, int r) {
 int left = l, right = r;

 while (left < right) {
 char tmp = s[left];
 s[left] = s[right];
 s[right] = tmp;
 left++;
 right--;
 }
 }
};

KamaCoder 54. 替换数字

链接：KamaCoder 54. 替换数字
文章：代码随想录
视频：无
状态：⚠️

第一想法

刚开始在纠结如何原地扩展；

代码随想录打卡第7天 | 454. 四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

Tue, 10 Mar 2026 00:00:00 +0000

454. 四数相加II

链接：力扣454
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

two sum的变形，把数组两两分组之后变成two sum；

看完题解后的想法

——

实现中遇到的困难

这里最开始看到分组都要两层循环，时间复杂度达到 $O(n^2)$ ，就觉得在查询逻辑里可以不用哈希直接遍历，因为也是两层循环；

但是这个是要考虑数组大小的，原来的数组大小是 $n$ ，分组求和之后就是 $n^2$ ，如果再两层遍历循环这个 $n^2$ 的数组复杂度就是 $O(n^4)$ ；

代码

class Solution {
public:
 int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
 unordered_map<int, int> hash;
 int cnt = 0;

 for (int i = 0; i < nums1.size(); i++) {
 for (int j = 0; j < nums2.size(); j++) {
 hash[nums1[i] + nums2[j]]++;
 }
 }

 for (int i = 0; i < nums3.size(); i++) {
 for (int j = 0; j < nums4.size(); j++) {
 int sum = nums3[i] + nums4[j];
 if (hash.count(-sum) != 0) {
 cnt += hash[-sum];
 }
 }
 }

 return cnt;
 }
};

383. 赎金信

链接：力扣383
文章：代码随想录
状态：✅

第一想法

类似于异构词，但是只用部分一致；

代码随想录打卡第6天 | 242. 有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

Mon, 09 Mar 2026 00:00:00 +0000

242. 有效的字母异位词

链接：力扣242
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

这道题要判断两个字符串包含的字符是否完全一致，第一想法就是哈希表；

仔细思考就会发现因为只有26个字符，所以不需要使用完整的哈希表，只需要使用一个定长数组模拟哈希就行了；

看完题解后的想法

——

实现中遇到的困难

最开始的时候将 s 的写入和判断的 t 的减少分开在了两个循环中，其实一次循环就能做；

代码

class Solution {
public:
 bool isAnagram(string s, string t) {
 if (s.size() != t.size()) {
 return false;
 }

 int cnt[26] = {};
 for (int i = 0; i < s.size(); i++) {
 cnt[s[i] - 'a']++;
 cnt[t[i] - 'a']--;
 }

 for (int c : cnt) {
 if (c != 0) {
 return false;
 }
 }
 return true;
 }
};

349. 两个数组的交集

链接：力扣349
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

使用集合去重+记录出现元素,之后再用集合去重;

代码随想录打卡第4天 | 24. 两两交换链表中的节点、19. 删除链表的倒数第N个节点、面试题02.07. 链表相交、142. 环形链表II

Sat, 07 Mar 2026 00:00:00 +0000

24. 两两交换链表中的节点

链接：力扣24
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

两两交换，头节点也要进入交换，要把这种特殊情况转变为一般情况，所以需要引入dummyHead；让之后的交换都是某个节点的next和next->next；变成了一般性问题；

还有就是三指针的交换顺序，这里采用标记了最后需要指向的节点降低心智负担；

看完题解后的想法

——

实现中遇到的困难

dummy.next忘记指向head了；

代码

class Solution {
public:
 ListNode* swapPairs(ListNode* head) {
 ListNode dummy(0);
 dummy.next = head;

 ListNode* cur = &dummy;

 while (cur->next != nullptr && cur->next->next != nullptr) {
 ListNode* finalFoward = cur->next->next->next;
 ListNode* firstMove = cur->next->next;
 ListNode* secondMove = cur->next;

 cur->next = firstMove;
 firstMove->next = secondMove;
 secondMove->next = finalFoward;

 cur = cur->next->next;
 }

 return dummy.next;
 }
};

19. 删除链表的倒数第N个节点

链接：力扣19
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

第一想法是反转链表，然后从头找过去，然后删除节点再返回来；

代码随想录打卡第3天 | 203. 移除链表元素、707. 设计链表、206. 反转链表

Fri, 06 Mar 2026 00:00:00 +0000

203. 移除链表元素

链接：力扣203
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

因为要删除节点，可能头节点本身也是要删除的，因此引入dummy_head，这样之后的所有节点都是next节点也不用区分是不是头节点；

看完题解后的想法

实现中遇到的困难

实现的时候忽略了next的next仍然可能是要删除的值；

代码

class Solution {
public:
 ListNode* removeElements(ListNode* head, int val) {
 ListNode dummy(INT_MAX);
 dummy.next = head;

 ListNode* cur = &dummy;
 while (cur->next != nullptr) {
 if (cur->next->val == val) {
 cur->next = cur->next->next;
 // 只是删掉了后继的第一个节点，可能有连续需要删除的
 } else {
 cur = cur->next;
 // 只有cur->next不是目标才能走
 }
 }

 return dummy.next;
 }
};

707. 设计链表

链接：力扣707
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

考察的是类的基本书写，需要注意各种代码规范；

因为有频繁的插入和删除，所以需要维护一个dummyHead来保证不用单独处理Head的情况；

代码随想录打卡第2天 | 209. 长度最小的子数组、59. 螺旋矩阵II、58. 区间和、44. 开发商购买土地

Thu, 05 Mar 2026 00:00:00 +0000

209. 长度最小的子数组

链接：力扣209
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

看到这道题的第一想法是做一个前缀和，但是引入前缀和之后需要去减去之后恰好小于target的另一个前缀和，遍历的话复杂度就会变成 $O(n^2)$ ，然后想到了可以二分查找；

但是仔细思考一下就会发现，可以维护一个队列，不断把数据push进去，一旦找到大于target的就开始把前面的数据踢出去，直到再次小于target；这样就不需要复杂的查找了；

看完题解后的想法

队列在这里其实就是一个双指针维护的滑动窗口；

实现中遇到的困难

result需要判断当前窗口大小和历史result谁更小，使用双指针滑动窗口不会有问题，但是如果是用队列来维护滑动窗口，需要使用queue.size(),返回的类型是size_t，需要强制转换成int；

一开始还给result直接赋值0，但是这样在min里会锁死最小值；

代码

class Solution {
public:
 int minSubArrayLen(int target, vector<int>& nums) {
 int sum = 0;
 int result = INT_MAX;
 int left = 0;

 for (int right = 0; right < nums.size(); right++) {
 sum += nums[right];

 while (sum >= target) {
 result = min(result, right-left+1);

 sum = sum - nums[left];
 left++;
 }
 }

 return result == INT_MAX ? 0 : result;;
 }
};

59. 螺旋矩阵II

链接：力扣59
文章：代码随想录
视频：B站讲解
状态：❌

第一想法

看完题目的第一想法就是如何移动坐标去填充数据，然后就被边界条件卡住了；

代码随想录打卡第1天 | 704. 二分查找、27. 移除元素、977. 有序数组的平方

Wed, 04 Mar 2026 00:00:00 +0000

704. 二分查找

链接：力扣704
文章：代码随想录
视频：B站讲解
状态：✅

第一想法

二分查找母题；

有闭区间和开区间两种解法：

闭区间：right 初始化为 nums.size()-1 ,是实右边界；在进入 while 循环时就要注意需要判断 left == right；同时每次移动边界都要从已经找到的地方往右或往左移动一步；

开区间：right 初始化为 nums.size() ,是虚右边界；在进入 while 循环时就要注意写 left < right；移动时左边界是 mid+1，而右边界是 mid；

看完题解后的想法

——

实现中遇到的困难

采用实变界进入循环的判断忘记了需要判断left == right；

代码

class Solution {
public:
 int search(vector<int>& nums, int target) {
 int left = 0;
 int right = nums.size()-1;

 while (left <= right) {
 int mid = left + (right-left)/2;

 if (nums[mid] == target) {
 return mid;
 } else if (nums[mid] > target) {
 right = mid-1;
 } else {
 left = mid+1;
 }
 }

 return -1;
 }
};

27. 移除元素

链接：力扣27
文章：代码随想录
视频：B站讲解
状态：⚠️

第一想法

第一想法就是维护两个指针，left 找到 val 位置，而 right 从右边找不为val的值，当左右相遇说明找完了；