LeetCode 热题 100之普通数组

1.最大子数组和

在这里插入图片描述
思路分析：这个问题可以通过动态规划来解决，我们可以使用Kadane’s Algorithm（卡登算法）来找到具有最大和的连续子数组。

Kadane’s Algorithm 的核心思想是利用一个变量存储当前的累加和 currentSum，并通过每次与之前的最大子数组和 maxSum 比较，更新 maxSum。它在遍历过程中不断累加子数组的和，但一旦累加和变为负数时，放弃当前累加，从下一个元素重新开始累加。这样确保了子数组和始终是最大的。
初始化：将 maxSum 和 currentSum 初始化为数组的第一个元素，即 nums[0]
遍历数组
- 从第二个元素开始，逐个元素检查累加currentSum;
  - currentSum = max(nums[i], currentSum + nums[i])：选择当前元素或当前累加和加上当前元素两者中的较大值。
  - 如果 currentSum 大于 maxSum，则更新 maxSum。
返回结果：遍历完成后，maxSum 即为最大子数组的和。

具体实现代码（详解版）：

class Solution {
public:int maxSubArray(std::vector<int>& nums) {int maxSum = nums[0];       // 初始化 maxSum 为数组第一个元素，用于存储最大子数组的和int currentSum = nums[0];    // 初始化 currentSum 为数组第一个元素，用于当前子数组的累加和// 遍历数组，从第二个元素开始（因为第一个元素已经初始化了）for (int i = 1; i < nums.size(); i++) {// 更新 currentSum，将当前元素和 currentSum + 当前元素 取较大值// 如果 currentSum + nums[i] 比 nums[i] 小，说明重新开始一个新的子数组会更大currentSum = max(nums[i], currentSum + nums[i]);// 更新 maxSum，存储最大子数组的和maxSum = max(maxSum, currentSum);}// 返回最大子数组的和return maxSum;}
};

2.合并区间

在这里插入图片描述
思路分析1（Acwing板子）
算法基础课-区间合并

具体实现代码（详解版）：

class Solution {
public:vector<vector<int>> merge(vector<vector<int>>& intervals) {vector<vector<int>> res;  // 用于存放合并后的区间结果sort(intervals.begin(), intervals.end());  // 按区间起点升序排序// 初始化st和ed为一个极小的值，用于在第一次遍历时识别有效区间int st = -2e9, ed = -2e9;// 遍历所有区间for (int i = 0; i < intervals.size(); i++) {// 如果当前区间的起点大于当前的结束位置，则无重叠if (ed < intervals[i][0]) {// 如果是有效区间，将前一个区间加入结果中if (st != -2e9) res.push_back({st, ed});// 更新st和ed为当前区间的起点和终点st = intervals[i][0];ed = intervals[i][1];} else {// 当前区间与前一个区间重叠，合并区间ed = max(ed, intervals[i][1]);}}// 添加最后一个区间到结果中if (st != -2e9) res.push_back({st, ed});return res;}
};

思路分析2：直接遍历区间数组，判断是否有重叠。

具体实现代码（详解版）：

class Solution {
public:vector<vector<int>> merge(vector<vector<int>>& intervals) {// 按区间的起始位置排序sort(intervals.begin(), intervals.end());// 用于存放合并后的结果vector<vector<int>> res;// 遍历区间数组for (const auto& interval : intervals) {// 如果结果数组为空或当前区间不与最后一个区间重叠，直接加入if (res.empty() || res.back()[1] < interval[0]) {res.push_back(interval);} else {// 否则，有重叠，更新最后一个区间的终点res.back()[1] = max(res.back()[1], interval[1]);}}return res;}
};

3.轮转数组

在这里插入图片描述
思路分析1：将后面k个元素和前面n-k个元素添加到res中即可。要注意k = k % n

具体实现代码（详解版）：

class Solution {
public:void rotate(vector<int>& nums, int k) {int n = nums.size();k = k % n;  // 如果 k 大于数组长度，取余数来简化操作vector<int> res;// 将最后 k 个元素加入结果中for (int i = n - k; i < n; ++i) res.push_back(nums[i]);// 然后把前 n - k 个元素加在结果后面for (int i = 0; i < n - k; ++i) res.push_back(nums[i]);// 将旋转后的结果更新到原数组nums = res;}
};

思路分析2：直接进行反转，先整体反转，再将将前 k 个元素反转，再将剩余的 n-k 个元素反转
具体实现代码（详解版）：

class Solution {
public:void rotate(vector<int>& nums, int k) {int n = nums.size();k = k % n;  // 计算实际旋转步数，防止 k 超出数组长度reverse(nums.begin(), nums.end());  // 1. 反转整个数组reverse(nums.begin(), nums.begin() + k);  // 2. 反转前 k 个元素reverse(nums.begin() + k, nums.end());  // 3. 反转剩余的 n-k 个元素}
};

在这里插入图片描述
很明显第二种方法更优！太快了！

4.除自身以外数组的乘积

在这里插入图片描述
思路分析：使用两个数组：一个数组存储每个元素左侧所有元素的乘积，另一个数组存储每个元素右侧所有元素的乘积。通过将这两个数组的对应元素相乘，得到每个位置的最终结果。

初始化：answer 数组初始化为 1，因为乘法的单位是 1
左侧乘积：
- 我们使用一个变量 left_product 来存储当前元素左侧的乘积。
- 对于每个元素 nums[i]，我们将 left_product 的值赋给 answer[i]，这表示在位置 i 的左侧乘积
- 然后，更新 left_product，将 nums[i] 的值乘入，准备计算下一个位置。
右侧乘积：我们继续使用之前的 answer 数组，它现在包含了每个元素左侧的乘积。接下来，我们将计算每个元素右侧的乘积。
- 使用一个变量 right_product 来存储当前元素右侧的乘积，并将其初始化为 1。
- 反向遍历
  - 对于每个元素 nums[i]，将 right_product 的值乘入 answer[i]，这样 answer[i] 就等于左侧乘积乘以右侧乘积
  - 更新 right_product，将 nums[i] 的值乘入，准备计算下一个位置。

具体实现代码（详解版）：

class Solution {
public:vector<int> productExceptSelf(vector<int>& nums) {int n = nums.size();vector<int> answer(n, 1); // 初始化结果数组为 1// 1. 计算左侧的乘积int left_product = 1; // 初始化左侧乘积for (int i = 0; i < n; i++) {answer[i] = left_product; // 设置 answer[i] 为左侧乘积left_product *= nums[i];   // 更新左侧乘积}// 2. 计算右侧的乘积并更新结果int right_product = 1; // 初始化右侧乘积for (int i = n - 1; i >= 0; i--) {answer[i] *= right_product; // 将右侧乘积乘以之前的结果right_product *= nums[i];    // 更新右侧乘积}return answer; // 返回最终结果}
};

另一种写法：

class Solution {
public:vector<int> productExceptSelf(vector<int>& nums) {int n = nums.size();vector<int> answer(n, 1); // 初始化结果数组// 计算左侧乘积for (int i = 1; i < n; ++i) {answer[i] = answer[i - 1] * nums[i - 1];}// 计算右侧乘积并更新 answerint right_product = 1;for (int i = n - 1; i >= 0; --i) {answer[i] *= right_product; // 将右侧乘积乘入结果right_product *= nums[i];   // 更新右侧乘积}return answer;}
};

还有这种双指针的做法，也是大为简洁！值得借鉴！

std::vector<int> productExceptSelf2(std::vector<int>& nums) {std::vector<int> answer(nums.size(), 1); // 初始化输出数组int left = 0, right = nums.size() - 1; // 指针初始化int lp = 1, rp = 1; // 左侧乘积和右侧乘积// 双指针法while (right >= 0 && left < nums.size()) {answer[right] *= rp; // 更新右侧元素的乘积answer[left] *= lp; // 更新左侧元素的乘积lp *= nums[left++]; // 更新左侧乘积rp *= nums[right--]; // 更新右侧乘积}return answer; // 返回结果
}

5.缺失的第一个正数

在这里插入图片描述
思路分析：要在时间复杂度O(n) 和常数级空间复杂度下找到未排序数组 nums 中最小的缺失正整数，我们可以采用原地哈希（或称为置换排序）的方式。具体思路如下：

目标：我们的目标是将每个正整数 x 放置在下标 x - 1 的位置上（例如，数字 1 应该放在下标 0 的位置，数字 2 应该放在下标 1，依此类推）。这样，如果数组中有数字 1, 2, …, n，它们都会出现在各自对应的位置上。
交换过程
- 遍历数组，如果nums[i]在[1,n]范围内，并且nums[i] != nums[nums[i] - 1],则将nums[i]放到其正确的位置num[i] -1。通过交换的方式来调整位置。
- 不断重复交换，直至当前位置的数字被放到了正确的位置为止。此过程会在 $O (n)$ 时间内完成，因为每个元素最多只会被交换一次
查找缺失的正整数
- 再次遍历数组，找到第一个位置i，使得nums[i] != i + 1,此时i + 1就是我们要找的最小的缺失正整数
- 如果所有位置都满足nums[i] == i + 1,那么数组中的所有正整数[1,n]都出现过，即最小缺失正整数为n + 1.

一个结论：不论数组 nums 是什么内容，数组长度为 N 时，最小缺失的正整数一定落在 [1, N+1]
这个范围内。这就是为什么算法中只需要关注 [1, N+1]，而无需遍历其他更大的数字的原因。

具体实现代码（详解版）：

class Solution {
public:int firstMissingPositive(vector<int>& nums) {int n = nums.size();//将每个数放到对应的位置for(int i = 0 ; i < n ; i ++){while(nums[i] > 0 && nums[i] <= n&& nums[i] != nums[nums[i] - 1] ){swap(nums[i],nums[nums[i] - 1]);}}//查找第一个位置i，使得nums[i] != i + 1for(int i = 0; i < n ; i ++){if(nums[i] != i + 1){return i + 1;}}//如果所有位置都正确，则返回 n + 1return n + 1;}
};