hot100--数组

目录

数组

1. 31. 下一个排列

2. 15. 三数之和

3. 169. 多数元素

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

 5.448. 找到所有数组中消失的数字

数组

1. 31. 下一个排列

中等

整数数组的一个 排列  就是将其所有成员以序列或线性顺序排列。

例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。

整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

• 例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
• 类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
• 而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。

给你一个整数数组 nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间。

示例 1：

输入：nums = [1,2,3]
输出：[1,3,2]

示例 2：

输入：nums = [3,2,1]
输出：[1,2,3]

示例 3：

输入：nums = [1,1,5]
输出：[1,5,1]

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 100

class Solution { public: void nextPermutation(vector<int>& nums) {         next_permutation(nums.begin(), nums.end());

        }

};

 解释：

C++ 标准库中的 next_permutation 函数，这个函数可以直接生成下一个字典序排列，无需手动实现算法。

2. 15. 三数之和

中等

给你一个整数数组 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 。

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

class Solution {
public:
    // 函数：找出数组中所有三个数相加等于零的组合
    vector<vector<int>> threeSum(vector<int>& nums) {
        // 创建一个二维向量来存储所有满足条件的三元组
        vector<vector<int>> result;

        // 对输入数组进行排序，这有助于后续的双指针查找
        sort(nums.begin(), nums.end());

        // 遍历数组，寻找可能的三元组
        for (int i = 0; i < nums.size(); ++i) {
            // 如果当前元素大于0，那么后续的元素都大于0，不可能再有三个数相加等于0
            if (nums[i] > 0) {
                break;
            }

            // 跳过重复的元素，避免重复的三元组
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            // 初始化两个指针，一个从当前元素的下一个位置开始，另一个从数组末尾开始
            int j = i + 1;
            int k = nums.size() - 1;

            // 使用双指针查找满足条件的三元组
            while (j < k) {
                // 计算三个数的和
                int tmpSum = nums[i] + nums[j] + nums[k];

                // 如果三个数的和等于0，说明找到了一个满足条件的三元组
                if (tmpSum == 0) {
                    // 将找到的三元组添加到结果中
                    result.push_back({nums[i], nums[j], nums[k]});

                    // 跳过重复的元素，避免重复的三元组
                    while (j < k && nums[j] == nums[j + 1]) {
                        ++j;
                    }
                    while (j < k && nums[k - 1] == nums[k]) {
                        --k;
                    }

                    // 移动指针，继续查找下一个可能的三元组
                    ++j;
                    --k;
                } 
                // 如果三个数的和小于0，说明需要增加和，因此移动左指针
                else if (tmpSum < 0) {
                    ++j;
                } 
                // 如果三个数的和大于0，说明需要减少和，因此移动右指针
                else {
                    --k;
                }
            }
        }

        // 返回包含所有满足条件的三元组的二维数组
        return result;
    }
};

3. 169. 多数元素

简单

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：nums = [3,2,3]
输出：3

示例 2：

输入：nums = [2,2,1,1,1,2,2]
输出：2

提示：

• n == nums.length
• 1 <= n <= 5 * 104
• -109 <= nums[i] <= 109

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int votes = 0; // 初始化投票计数器
        int x = 0;     // 初始化候选元素

        // 遍历数组中的每个元素
        for(auto num : nums) {
            // 如果 votes 为 0，说明当前没有候选元素，将 num 设置为候选元素 x
            if (votes == 0) x = num;

            // 如果 num 与当前候选元素 x 相同，投票数加 1，否则减 1
            votes += (x == num) ? 1 : -1;
        }

        // 最终返回候选元素 x，题目保证了 x 一定是多数元素
        return x;
    }
};
 

解释：

Boyer-Moore 投票算法之所以有效，是因为如果数组中存在多数元素，它最终会在对抗中“胜出”，并在遍历结束后成为候选元素。 

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

中等

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。

请 不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]

示例 2:

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

提示：

• 2 <= nums.length <= 105
• -30 <= nums[i] <= 30
• 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int len = nums.size();  // 获取输入数组的长度
        if (len == 0) return {};  // 如果数组为空，直接返回空数组

        vector<int> ans(len, 1);  // 初始化结果数组，所有元素初始值为1
        ans[0] = 1;  // 第一个元素的左侧没有元素，所以它的左侧乘积为1

        int tmp = 1;  // 用于存储当前元素右侧所有元素的乘积

        // 第一次遍历：计算每个元素左侧所有元素的乘积
        for (int i = 1; i < len; i++) {
            ans[i] = ans[i - 1] * nums[i - 1];  // ans[i] 存储从 nums[0] 到 nums[i-1] 的乘积
        }

        // 第二次遍历：计算每个元素右侧所有元素的乘积，并与左侧乘积相乘
        for (int i = len - 2; i >= 0; i--) {
            tmp *= nums[i + 1];  // tmp 存储从 nums[i+1] 到 nums[len-1] 的乘积
            ans[i] *= tmp;  // ans[i] 现在是除了 nums[i] 之外所有元素的乘积
        }

        return ans;  // 返回结果数组
    }
};

 5.448. 找到所有数组中消失的数字

简单

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。

示例 1：

输入：nums = [4,3,2,7,8,2,3,1]
输出：[5,6]

示例 2：

输入：nums = [1,1]
输出：[2]

提示：

• n == nums.length
• 1 <= n <= 105
• 1 <= nums[i] <= n

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans;
        // 将数组中的每个数字转换为1到n之间的索引，并标记出现次数
        for (int i = 0; i < n; ++i) {
            int index = abs(nums[i]) - 1;
            if (nums[index] > 0) {
                nums[index] = -nums[index]; // 标记为负数表示该数字已经出现过
            }
        }
        // 找

{
                ans.push_back(i + 1); // 将缺失数字的索引+1加入到结果向量ans中
            }
        }
        return ans;
    }
};