南通网站备案以下属于网站seo的内容是

引言：此专栏为记录算法学习，本专题作为算法学习的第一部分，优选算法专题共计100题，分为不同小模块进行，算法学习需坚持积累，时代不会辜负长期主义者，仅以此句，与君共勉。

讲解算法分为三个步骤：(1) 题目分析 （2）算法原理 （3）代码编写

下面的所有题目讲解都会以上述三个步骤开展

---

1. 移动零     283. 移动零 - 力扣（LeetCode）

(1) 题目分析：

给定一个数组 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

原地操作，将所有0移动到数组右侧

示例 ：nums = [0,1,0,3,1,2]    ---> [1,3,1,2,0,0]

(2) 算法原理：（快排的思想：数组划分区间 - 数组分两块）：

双指针算法 -- 利用数组下标来充当指针 (这里我们定义两个指针   cur , dest)

两个指针的作用：

cur : 从左往右扫描数组，遍历数组

dest:  已处理的区间内，非零元素的最后一个位置

如何做到：

1.cur 遇到0元素，cur++

2，遇到非0元素，swap(dest+1,cur);

dest++ ,cur++;

(3)代码编写

这里注意一下dest使用的是前置++还是后置++取决于dest的起始位置

class Solution {
public:void moveZeroes(vector<int>& nums) {for(int cur = 0, dest = 0; cur < nums.size(); cur++)if(nums[cur]){swap(nums[dest++], nums[cur]); } }
};

class Solution {
public:void moveZeroes(vector<int>& nums) {for(int cur = 0, dest = -1; cur < nums.size(); cur++)if(nums[cur]){swap(nums[++dest], nums[cur]); } }
};

这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆 解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。

---

2. 复写零     1089. 复写零 - 力扣（LeetCode）

(1）题目分析 

给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。

注意：请不要在超过该数组长度的位置写入元素。请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

示例 1：

输入：arr = [1,0,2,3,0,4,5,0]
输出：[1,0,0,2,3,0,0,4]
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]

示例 2：

输入：arr = [1,2,3]
输出：[1,2,3]
解释：调用函数后，输入的数组将被修改为：[1,2,3]

这里我们要注意的问题是数组的长度是固定的，要复写0，原数组里可能会有数据就不存在了，所以我们可以先找到复写完的最后一个位置的元素，再从前往后完成复写操作

（2）算法原理 

如果从前向后进行原地复写操作的话，由于0的复写操作，导致没有复写的数被覆盖掉，因此我们选择从后往前的复写策略。

但是从后向前复写的时候，我们需要找到最后一个复写的数，大致分为两步：

1. 先找到最后一个复写的数

2.然后从后面向前进行复写操作

流程：

先根据“异地”操作，然后优化成双指针的“就地”操作

a. 先找到最后一个”复写“的数：

    1.先判断cur位置的值

    2.决dest移动两步还是一步

    3.判断一下dest是否已经到结束为止

    4.cur++

b.处理一下边界情况

    n-1 ---> 0 

    cur --;

    dest -= 2;

c.从后向前完成复写操作

示意图：

（3）代码编写 

class Solution
{
public:void duplicateZeros(vector<int>& arr) {// 1. 先找到最后⼀个数int cur = 0, dest = -1, n = arr.size();while(cur < n){if(arr[cur]) dest++;else dest += 2;if(dest >= n - 1) break;cur++;}// 2. 处理⼀下边界情况if(dest == n){arr[n - 1] = 0;cur--; dest -=2;}// 3. 从后向前完成复写操作while(cur >= 0){if(arr[cur]) arr[dest--] = arr[cur--];else{arr[dest--] = 0;arr[dest--] = 0;cur--;}}}
};

class Solution {
public:void duplicateZeros(vector<int>& arr) {int n = arr.size();int i = 0, j = 0;// 第一遍扫描：计算复制后的新长度while (j < n) {if (arr[i] == 0) j++;i++;j++;}// 回退指针准备复制i--;j--;// 第二遍扫描：从后向前复制元素while (i >= 0) {if (j < n) arr[j] = arr[i];if (arr[i] == 0) {j--;if (j < n) arr[j] = 0;}i--;j--;}}
};

---

3. 快乐数       202. 快乐数 - 力扣（LeetCode）

（1）题目分析

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

（2）算法原理

详解：Leet code每日一题-CSDN博客

（3）代码编写 

class Solution {
public:int squre_sum(int n){int sum = 0;while(n){int t = n %10;sum += t*t;n /= 10;}return sum;}bool isHappy(int n) {int slow = n,fast = squre_sum(n); while(slow != fast){slow = squre_sum(slow);fast = squre_sum(squre_sum(fast));}return slow == 1;} 
};

---

 4. 盛最多水的类型      11. 盛最多水的容器 - 力扣（LeetCode）

（1）题目分析 

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

（2）算法原理 

Leet code 每日一题-CSDN博客

（3）代码编写 

class Solution {
public:int maxArea(vector<int>& height){int left = 0,right = height.size()-1,ret = 0;while(left < right){int v = min(height[left] , height[right])*(right - left);ret = max(ret , v);if(height[left] < height[right]) left++;else right--;}return ret;}
};

---

5.有效三角形的个数     611. 有效三角形的个数 - 力扣（LeetCode）

（1）题目分析 

给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。

示例 1:

输入: nums = [2,2,3,4]

输出: 3

解释:

有效的组合是: 2,3,4 (使用第一个 2)

2,3,4 (使用第二个 2) 2,2,3

示例 2:

输入: nums = [4,2,3,4]

输出: 4

（2）算法原理 

Leet code 每日一题-CSDN博客

（3）代码编写   

class Solution {
public:int triangleNumber(vector<int>& nums) {sort(nums.begin(),nums.end());int ret = 0,n = nums.size();for(int i = n-1;i>=2;i--){int left = 0, right = i -1;while(left < right){if(nums[left] +nums[right] > nums[i]){ret += right -left;right--;}else{left++;}}}return ret;}        
};

---

6.和为S的两个数LCR 179. 查找总价格为目标值的两个商品 - 力扣（LeetCode）

（1）题目分析 

购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。

示例 1：

输入：price = [3, 9, 12, 15], target = 18
输出：[3,15] 或者 [15,3]

示例 2：

输入：price = [8, 21, 27, 34, 52, 66], target = 61
输出：[27,34] 或者 [34,27]

（2）算法原理 

解法⼀（暴⼒解法，会超时）：

算法思路：

两层 for 循环列出所有两个数字的组合，判断是否等于⽬标值。

算法流程：

两层 for 循环：

◦

外层 for 循环依次枚举第⼀个数 a ；

◦

内层 for 循环依次枚举第⼆个数 b ，让它与 a 匹配；

ps ：这⾥有个魔⻤细节：我们挑选第⼆个数的时候，可以不从第⼀个数开始选，因为 a 前

⾯的数我们都已经在之前考虑过了；因此，我们可以从 a 往后的数开始列举。

◦

然后将挑选的两个数相加，判断是否符和目标值

. 解法⼆（双指针 - 对撞指针）：

注意到本题是升序的数组，因此可以⽤「对撞指针」优化时间复杂度。

算法流程（附带算法分析，为什么可以使⽤对撞指针）：

a. 初始化 left ， right 分别指向数组的左右两端（这⾥不是我们理解的指针，⽽是数组的下

标）

b. 当 left < right 的时候，⼀直循环

i. 当 nums[left] + nums[right] == target 时，说明找到结果，记录结果，并且

返回；

ii. 当 nums[left] + nums[right] < target 时：

•

对于 nums[left] ⽽⾔，此时 nums[right] 相当于是 nums[left] 能碰到的

最⼤值（别忘了，这⾥是升序数组哈~）。如果此时不符合要求，说明在这个数组⾥⾯，

没有别的数符合 nums[left] 的要求了（最⼤的数都满⾜不了你，你已经没救了）。

因此，我们可以⼤胆舍去这个数，让 left++ ，去⽐较下⼀组数据；

•

那对于 nums[right] ⽽⾔，由于此时两数之和是⼩于⽬标值的， nums[right]

还可以选择⽐ nums[left] ⼤的值继续努⼒达到⽬标值，因此 right 指针我们按

兵不动；

iii. 当 nums[left] + nums[right] > target 时，同理我们可以舍去

nums[right] （最⼩的数都满⾜不了你，你也没救了）。让 right-- ，继续⽐较下⼀

组数据，⽽ left 指针不变（因为他还是可以去匹配⽐ nums[right] 更⼩的数的）。

（3）代码编写  

class Solution
{
public:vector<int> twoSum(vector<int>& nums, int target){int left = 0, right = nums.size() - 1;while(left < right){int sum = nums[left] + nums[right];if(sum > target) right--;else if(sum < target) left++;else return {nums[left], nums[right]};}// 照顾编译器return {-4941, -1};​​​​​​​ }
};

---

7. 三数之和 15. 三数之和 - 力扣（LeetCode）

（1）题目分析 

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

（2）算法原理 

解法（排序+双指针）：

算法思路：

本题与两数之和类似，是⾮常经典的⾯试题。

与两数之和稍微不同的是，题⽬中要求找到所有「不重复」的三元组。那我们可以利⽤在两数之和

那⾥⽤的双指针思想，来对我们的暴⼒枚举做优化：

i. 先排序；

ii. 然后固定⼀个数 a ：

iii. 在这个数后⾯的区间内，使⽤「双指针算法」快速找到两个数之和等于 -a 即可。

但是要注意的是，这道题⾥⾯需要有「去重」操作~

i. 找到⼀个结果之后， left 和 right 指针要「跳过重复」的元素；

ii. 当使⽤完⼀次双指针算法之后，固定的 a 也要「跳过重复」的元素。

（3）代码编写

class Solution
{
public:vector<vector<int>> threeSum(vector<int>& nums) {vector<vector<int>> ret;// 1. 排序sort(nums.begin(), nums.end());// 2. 利⽤双指针解决问题int n = nums.size();for(int i = 0; i < n; ) // 固定数 a{if(nums[i] > 0) break; // ⼩优化int left = i + 1, right = n - 1, target = -nums[i];while(left < right){int sum = nums[left] + nums[right];if(sum > target) right--;else if(sum < target) left++;else{ret.push_back({nums[i], nums[left], nums[right]});left++, right--;// 去重操作 left 和 rightwhile(left < right && nums[left] == nums[left - 1]) left++;while(left < right && nums[right] == nums[right + 1]) 
right--;}}// 去重 i i++;while(i < n && nums[i] == nums[i - 1]) i++;}return ret;}
};

---

8.四数之和 18. 四数之和 - 力扣（LeetCode）

（1）题目分析 

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

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

示例 1：

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

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

（2）算法原理 

.解法（排序 + 双指针）

算法思路：

a. 依次固定⼀个数 a ；

b. 在这个数 a 的后⾯区间上，利⽤「三数之和」找到三个数，使这三个数的和等于 target

- a 即可

（3）代码编写  

class Solution
{
public:vector<vector<int>> fourSum(vector<int>& nums, int target) {vector<vector<int>> ret;// 1. 排序sort(nums.begin(), nums.end());// 2. 利⽤双指针解决问题int n = nums.size();for(int i = 0; i < n; ) // 固定数 a{// 利⽤ 三数之和for(int j = i + 1; j < n; ) // 固定数 b{// 双指针int left = j + 1, right = n - 1;long long aim = (long long)target - nums[i] - nums[j];while(left < right){int sum = nums[left] + nums[right];if(sum < aim) left++;else if(sum > aim) right--;else{ret.push_back({nums[i], nums[j], nums[left++], nums[right--]});// 去重⼀while(left < right && nums[left] == nums[left - 1]) left++;while(left < right && nums[right] == nums[right + 1]) right--;}}// 去重⼆j++;while(j < n && nums[j] == nums[j - 1]) j++;}// 去重三i++;while(i < n && nums[i] == nums[i - 1]) i++;}return ret;}
};