Hot100——普通数组

53最大子数字

思路

1. 核心思想：

   • 遍历数组时，持续维护一个当前子数组的和（now）
   • 同时记录遍历过程中遇到的最大子数组和（ans）

2. 具体逻辑：

   • 初始化 now 为 0（当前子数组和），ans 为一个极小值（-1e9，确保能覆盖所有可能的负值情况）
   • 遍历数组中的每个元素：
     • 将当前元素加入 now（扩展当前子数组）
     • 用 now 更新 ans（保留最大值）
     • 如果 now 小于 0，说明当前子数组的和为负，继续保留会拖累后续结果，因此重置 now 为 0（相当于重新开始一个新的子数组）

3. 适用场景：

   • 解决 "最大子序和" 问题，即从整数数组中找出一个具有最大和的连续子数组
   • 能高效处理包含负数的数组，例如 [-2,1,-3,4,-1,2,1,-5,4] 这样的输入，会正确返回 6（对应子数组 [4,-1,2,1]）

这个算法的优势在于只需要一次遍历就能得到结果，是解决此类问题的最优方案之一。

代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),[](const vector<int> &a,const vector<int> &b)
        {
            if(a[0]!=b[0])
            {
                return a[0]<b[0];
            }
            return a[1]<b[1];
        });

        vector<vector<int>> ans;

        int st=intervals[0][0],end=intervals[0][1];
        for(int i=1;i<intervals.size();i++)
        {
            if(intervals[i][0]<=end)
            {
                end=max(end,intervals[i][1]);
            }
            else 
            {
                ans.push_back({st,end});
                st=intervals[i][0];
                end=intervals[i][1];
            }
        }
        ans.push_back({st,end});
        return ans;

    }
};

56合并区间

思路

1. 区间排序：

   • 首先对所有区间进行排序，排序规则是先按区间的起始位置（a[0]）升序排列
   • 若起始位置相同，则按区间的结束位置（a[1]）升序排列
   • 排序的目的是让后续的合并过程可以按顺序进行，确保相邻的区间在物理位置上也相邻

2. 区间合并逻辑：

   • 初始化st和end为第一个区间的起始和结束位置
   • 从第二个区间开始遍历：
     • 若当前区间的起始位置intervals[i][0]小于等于end，说明两个区间重叠或相邻，将end更新为两个区间结束位置的最大值（合并区间）
     • 若当前区间的起始位置大于end，说明两个区间不重叠，将之前合并好的区间[st, end]加入结果集，然后更新st和end为当前区间的起始和结束位置
   • 遍历结束后，将最后一个合并的区间加入结果集

3. 示例说明：

   • 对于输入[[1,3],[2,6],[8,10],[15,18]]，排序后不变
   • 合并过程：[1,3]与[2,6]合并为[1,6]，然后[8,10]和[15,18]保持不变
   • 最终结果为[[1,6],[8,10],[15,18]]

该算法的时间复杂度主要由排序步骤决定，为O(n log n)，空间复杂度为O(1)（不考虑存储结果所需的空间），是区间合并问题的经典高效解法。

代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),[](const vector<int> &a,const vector<int> &b)
        {
            if(a[0]!=b[0])
            {
                return a[0]<b[0];
            }
            return a[1]<b[1];
        });

        vector<vector<int>> ans;

        int st=intervals[0][0],end=intervals[0][1];
        for(int i=1;i<intervals.size();i++)
        {
            if(intervals[i][0]<=end)
            {
                end=max(end,intervals[i][1]);
            }
            else 
            {
                ans.push_back({st,end});
                st=intervals[i][0];
                end=intervals[i][1];
            }
        }
        ans.push_back({st,end});
        return ans;

    }
};

189轮转数组

思路

这段代码实现了数组的向右旋转操作，采用了基于最大公约数（GCD）的环状替换算法，是一种高效的原地旋转方法。具体解析如下：

核心思路

利用数组长度 n 和旋转步数 k 的最大公约数（GCD）来确定旋转的 "环" 数量，每个环内的元素通过环状替换完成旋转，从而实现整体数组的旋转效果。

步骤分解

1. 特殊情况处理 ：当 k=0 时，无需旋转，直接返回。

2. 计算最大公约数：

   • 通过自定义的 mygcd 函数计算数组长度 nums.size() 与旋转步数 k 的最大公约数 ma。
   • 这个 ma 决定了需要处理的环的数量（即需要进行 ma 次独立的环状替换）。

3. 环状替换过程：

   • 对每个环（从 pos=0 到 pos < ma）进行处理：
     • 保存当前位置 pos 的元素值 last。
     • 通过 now = (now + k) % n 计算下一个要替换的位置。
     • 依次将 last 的值放入下一个位置，同时更新 last 为被替换的元素值。
     • 当 now 回到初始位置 pos 时，完成一个环的替换，将最后保存的 last 放入 pos 位置。
   • 递增 pos，处理下一个环，直到所有环都处理完毕。

优势分析

• 空间效率 ：原地旋转，仅使用常数级额外空间（O(1)）。
• 时间效率 ：每个元素仅被移动一次，总时间复杂度为 O(n)。
• 适用性 ：适用于任意长度的数组和任意旋转步数，包括 k 大于数组长度的情况（通过取模自动处理）。

例如，对于数组 [1,2,3,4,5,6] 和 k=2：

• 数组长度为 6，GCD(6,2)=2，需要处理 2 个环。
• 第一个环（pos=0）：0→2→4→0，元素依次替换。
• 第二个环（pos=1）：1→3→5→1，元素依次替换。
• 最终结果为 [5,6,1,2,3,4]，实现了向右旋转 2 步的效果。

这种算法巧妙利用数学性质减少了操作次数，是数组旋转问题的最优解法之一。

代码

class Solution {
public:

    int mygcd(int a,int b)
    {
        if(a<b)swap(a,b);
        if(b==0)return a;
        return mygcd(b,a%b);
    }

    void rotate(vector<int>& nums, int k) {
        int pos=0;
        if(k==0)return;
        int ma=mygcd(nums.size(),k);
        while (pos < nums.size() && pos < ma)
        {
            int last = nums[pos];
            int tmp;
            int now = pos;
            now += k;
            while (now != pos)
            {
                //cout<<now<<endl;
                now %= nums.size();
                tmp = nums[now];
                nums[now] = last;
                last = tmp;
                now += k;
                now %= nums.size();
            }
            nums[pos] = last;
            pos++;
        }
    }
};

238除自身以外数组的乘积

思路

算法思路解析：

1. 核心思想：

   • 利用两次遍历，分别计算每个元素左侧所有元素的乘积和右侧所有元素的乘积
   • 将这两个乘积相乘，即可得到每个位置除除自身外所有元素的乘积

2. 具体步骤：

   • 第一次遍历（左到右）：

     • 初始化 answer[0] = 1（第一个元素左侧没有元素，乘积为 1）
     • 对于 i > 0，answer[i] 存储 nums[0] 到 nums[i-1] 的乘积（即当前元素左侧所有元素的乘积）

   • 第二次遍历（右到左）：

     • 初始化 R = 1（右侧乘积的初始值）
     • 对于每个 i，answer[i] 乘以 R（即当前元素右侧所有元素的乘积）
     • 更新 R 为 R * nums[i]（将当前元素加入右侧乘积，供左侧元素使用）

3. 优势分析：

   • 避免了使用除法（处理了数组中可能包含 0 的情况）
   • 仅使用常数额外空间，效率极高
   • 两次线性遍历，时间复杂度为 O (n)

代码

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();
        vector<int> answer(length);

        answer[0] = 1;
        for (int i = 1; i < length; i++) {
            answer[i] = nums[i - 1] * answer[i - 1];
        }
        int R = 1;
        for (int i = length - 1; i >= 0; i--) {

            answer[i] = answer[i] * R;

            R *= nums[i];
        }
        return answer;
    }
};

41缺失的第一个正数

思路

代码

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        for(int i=0;i<nums.size();i++)
        {
            while(nums[i]>0&&nums[i]<nums.size())
            {
                swap(nums[i],nums[nums[i]-1]);
                if(nums[i]<=0||nums[i]>=nums.size()||nums[i]==i+1||nums[i]==nums[nums[i]-1])break;
            }
        }

        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]!=i+1)return i+1;
        }

        return nums.size()+1;
    }
};