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 即为最大子数组的和。

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

cpp 复制代码

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板子）
算法基础课-区间合并

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

cpp 复制代码

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：直接遍历区间数组，判断是否有重叠。

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

cpp 复制代码

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

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

cpp 复制代码

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 个元素反转

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

cpp 复制代码

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] 的值乘入，准备计算下一个位置。

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

cpp 复制代码

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; // 返回最终结果
    }
};

另一种写法：

cpp 复制代码

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];
        }

        // 计算右侧乘积并更新 answer
        int right_product = 1;
        for (int i = n - 1; i >= 0; --i) {
            answer[i] *= right_product; // 将右侧乘积乘入结果
            right_product *= nums[i];   // 更新右侧乘积
        }

        return answer;
    }
};

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

cpp 复制代码

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 ) O(n) 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]，而无需遍历其他更大的数字的原因。

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

cpp 复制代码

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 + 1
        for(int i = 0; i < n ; i ++){
            if(nums[i] != i + 1){
                return i + 1;
            }
        }
        //如果所有位置都正确，则返回 n + 1
        return n + 1;
    }
};