ASDF的博客

【LeetCode-中等】18.四数之和 - 哈希/双指针

【LeetCode-中等】33.搜索旋转排序数组 - 二分法

【LeetCode-中等】59.螺旋矩阵II - 二维数组

【LeetCode-中等】209.长度最小的子数组-双指针/滑动窗口

【LeetCode-简单】27.移除元素 - 数组与双指针法

69.x的平方根 367.有效的完全平方数 二分查找

20. 有效的括号

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

【LeetCode-简单】9. 回文数

12. 整数转罗马数字

leetcode 13

leetcode 2. 两数相加

136. 只出现一次的数字如果不考虑时间复杂度和空间复杂度的限制，这道题有很多种解法，可能的解法有如下几种：使用集合存储数字。遍历数组中的每个数字，如果集合中没有该数字，则将该数字加入集合，如果集合中已经有该数字，则将该数字从集合中删除，最后剩下的数字就是只出现一次的数字。使用哈希表存储每个数字和该数字出现的次数。遍历数组即可得到每个数字出现的次数，并更新哈希表，最后遍历哈希表，得到只出现一次的数字。使用集合存储数组中出现的所有数字，并计算数组中的元素之和。由于集合保证元素无重复，因此计算集合中

190. 颠倒二进制位解法一：逐位颠倒将 n 视作一个长为 32 的二进制串，从低位往高位枚举 n 的每一位，将其倒序添加到翻转结果 ans 中。代码实现中，每枚举一位就将 n 右移一位，这样当前 n 的最低位就是我们要枚举的比特位。当 n 为 0 时即可结束循环。class Solution {public: uint32_t reverseBits(uint32_t n) { uint32_t ans=0; for(int i=0;i<32;i+

191. 位1的个数解法一：循环检查二进制位直接循环检查给定整数 n 的二进制位的每一位是否为 1。当检查第 i 位时，让 n 与 1<<i 进行与运算，当且仅当 n 的第 i 位为 1 时，运算结果不为 0。

231. 2 的幂

120. 三角形最小路径和一道非常经典且历史悠久的动态规划题解法：动态规划用 dp[i][j] 表示从三角形顶部走到位置 (i, j) 的最小路径和。这里的位置 (i, j) 指的是三角形中第 i 行第 j 列（均从 0 开始编号）的位置。由于每一步只能移动到下一行「相邻的节点」上，因此要想走到位置 (i, j)，上一步就只能在位置 (i-1, j-1) 或者位置 (i - 1, j) 中选择一个路径和较小的来进行转移，状态转移方程为：dp[i][j]=min(dp[i−1][j−1], d

198. 打家劫舍解法：动态规划最简单的情况：只有一间房屋，则偷窃该房屋，可以偷窃到最高总金额，即dp[0]=nums[0]；只有两间房屋，由于两间房屋相邻，不能同时偷窃，只能选择其中金额较高的房屋进行偷窃，可以偷窃到最高总金额，即dp[1]=max(nums[0],nums[1])。房屋数量大于两间，应该如何计算能够偷窃到的最高总金额呢？对于第 k (k>2) 间房屋，有两种选择：偷窃第 k 间房屋，偷窃总金额为前 k−2 间房屋的最高总金额与第 k 间房屋的金额之和，即dp[i−2]+

70. 爬楼梯解法：动态规划也是斐波那契数列class Solution {public: int climbStairs(int n) { int dp[1024]; dp[1]=1; dp[2]=2; dp[3]=3; for(int i=4;i<=n;i++){ dp[i]=dp[i-1]+dp[i-2]; } return dp[n];

784. 字母大小写全排列解法：递归从左往右依次遍历字符，过程中保持 ans 为已遍历过字符的字母大小全排列。例如，当 S = “abc” 时，考虑字母 “a”, “b”, “c”，初始令 ans = [""]，依次更新 ans = [“a”, “A”]， ans = [“ab”, “Ab”, “aB”, “AB”]， ans = [“abc”, “Abc”, “aBc”, “ABc”, “abC”, “AbC”, “aBC”, “ABC”]。如果下一个字符 c 是字母，将当前已遍历过的字符串全排

46. 全排列解法：回溯回溯法：一种通过探索所有可能的候选解来找出所有的解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化抛弃该解，即回溯并且再次尝试。详解见：题解class Solution {public: vector<vector<int>> permute(vector<int>& nums) { vector<vector<int>> res;

77. 组合解法：递归class Solution {public: vector<int> temp; vector<vector<int>> ans; vector<vector<int>> combine(int n, int k) { dfs(1,n,k); return ans; } void dfs(int cur,int n,int k){

206. 反转链表解法一：递归/** * 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)

21. 合并两个有序链表解法一：迭代/** * 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

994. 腐烂的橘子解法：BFS思路与116. 填充每个节点的下一个右侧节点指针有相通之处。注意网格中没有腐烂的橘子的情况（如[[0]]，[[1]]），前者结果应为0，后者结果为-1。class Solution {public: int orangesRotting(vector<vector<int>>& grid) { int n=grid.size(),m=grid[0].size(); vector<vec

542. 01 矩阵解法：BFS把所有的 0 看成一个整体，以它为起点进行广度优先搜索。另设置 see 数组存储当前点是否已被搜索过。class Solution {public: vector<vector<int>> updateMatrix(vector<vector<int>>& mat) { int dx[4]={0,1,-1,0}; int dy[4]={1,0,0,-1};

116. 填充每个节点的下一个右侧节点指针解法一：层次遍历层次遍历基于广度优先搜索，它与广度优先搜索的不同之处在于，广度优先搜索每次只会取出一个节点来拓展，而层次遍历会每次将队列中的所有元素都拿出来拓展，这样能保证每次从队列中拿出来遍历的元素都是属于同一层的，因此我们可以在遍历的过程中修改每个节点的 next 指针，并拓展下一层的新队列。/*// Definition for a Node.class Node {public: int val; Node* left;

617. 合并二叉树解法：DFS使用深度优先搜索合并两个二叉树。从根节点开始同时遍历两个二叉树，并将对应的节点进行合并。如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空；如果两个二叉树的对应节点只有一个为空，则合并后的二叉树的对应节点为其中的非空节点；如果两个二叉树的对应节点都不为空，则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和。/** * Definition for a binary tree node. * struct TreeNode { *

695. 岛屿的最大面积

leetcode 733.图像渲染

567. 字符串的排列解法：滑动窗口由于排列不会改变字符串中每个字符的个数，所以只有当两个字符串每个字符的个数均相等时，一个字符串才是另一个字符串的排列。记 s1 的长度为 n，遍历 s2 中的每个长度为 n 的子串，判断子串和 s1 中每个字符的个数是否相等，若相等则说明该子串是 s1 的一个排列。滑动窗口每向右滑动一次，就多统计一次进入窗口的字符，少统计一次离开窗口的字符。class Solution {public: bool checkInclusion(string s1

3. 无重复字符的最长子串解法：滑动窗口以abcabcbb 为例，找出从每一个字符开始的，不包含重复字符的最长子串这样一来，就可以使用**「滑动窗口」**来解决这个问题了：使用两个指针表示字符串中的某个子串（或窗口）的左右边界，其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为「不包含重复字符的最长子串的结束位置 rk 」；在每一步的操作中，将左指针向右移动一格，表示我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。

19. 删除链表的倒数第 N 个结点在 head 前添加哑节点 dummy ，使头节点 head 无需特殊处理。解法一：计算链表长度/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(n

876. 链表的中间结点注意 head 指针指向第一个数解法一：单指针法/** * 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

557. 反转字符串中的单词 III要注意对最后一个单词的处理，最后一个单词的后面没有空格class Solution {public: string reverseWords(string s) { int len=s.size(); int left=0,right=1; while(right<len){ if(s[right]==' '){ int low=left,high

344. 反转字符串很简单的双指针题目，没啥可说的class Solution {public: void reverseString(vector<char>& s) { int len=s.size(); int left=0,right=len-1; while(left<right){ swap(s[left],s[right]); left++;

167. 两数之和 II - 输入有序数组很简单的双指针的题目class Solution {public: vector<int> twoSum(vector<int>& numbers, int target) { int len=numbers.size(); int left=0,right=len-1; while(numbers[left]+numbers[right]!=target){

283. 移动零题目：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。注意：要求在原数组上操作解法一：不用双指针很简单易懂的一种方式，非 0 的值直接覆盖，后面补0class Solution {public: void moveZeroes(vector<int>& nums) { int count=0; for(int i=0;i<nums.size();i++){

189. 轮转数组题目：给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。解法一：从原数组的第 nums.size()-k 位开始加到答案数组中，然后将原数组的前 nums.size()-k 位加到答案数组中，即为向右轮转 k 位后的结果。需要注意 k>nums.size() 的情况，例：nums.size()=3，k=4 向右轮转4位的结果与向右轮转1位相同，nums.size()-k 值为负数，需要额外处理。class Solution {public:

977. 有序数组的平方