力扣热题 100：普通数组专题五道题详细解析(JAVA)-优快云博客

系列文章目录

在力扣（LeetCode）平台上，热题 100 是许多开发者提升算法能力的必刷清单。今天，我们就来详细解析热题 100 中与普通数组相关的五道题，帮助大家更好地理解解题思路和技巧。

一、最大子数组和

1. 题目描述

给定一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

2. 示例

示例 1：

输入：nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]

输出：6

解释：连续子数组 [4, -1, 2, 1] 的和最大，为 6。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来维护当前最大子数组和。具体步骤如下：

初始化两个变量 maxSum 和 currentSum，分别表示当前最大子数组和和当前子数组和。
遍历数组，对于每个元素 nums[i]：
- 更新 currentSum 为 currentSum + nums[i] 和 nums[i] 中的较大值。
- 更新 maxSum 为 maxSum 和 currentSum 中的较大值。
返回 maxSum。

4. 代码实现（Java）

public class Solution {
    public int maxSubArray(int[] nums) {
        int maxSum = nums[0];
        int currentSum = nums[0];
        for (int i = 1; i < nums.length; i++) {
            currentSum = Math.max(currentSum + nums[i], nums[i]);
            maxSum = Math.max(maxSum, currentSum);
        }
        return maxSum;
    }
}

5. 复杂度分析

时间复杂度 ：O(n)，其中 n 是数组的长度。我们只需要遍历数组一次。
空间复杂度 ：O(1)，我们只使用了常数级别的额外空间。

二、合并区间

1. 题目描述

给定一个区间列表 intervals，其中每个区间为 [start, end]，请你合并所有重叠的区间，并返回合并后的区间列表。

2. 示例

示例 1：

输入：intervals = [[1, 3], [2, 6], [8, 10], [15, 18]]

输出：[[1, 6], [8, 10], [15, 18]]

解释：区间 [1, 3] 和 [2, 6] 重叠，合并为 [1, 6]。

3. 解题思路

这道题主要考察排序和区间合并。我们可以先对区间列表按照区间的起始位置进行排序，然后遍历排序后的区间列表，合并重叠的区间。具体步骤如下：

对区间列表按照区间的起始位置进行排序。
初始化一个结果列表 result，将第一个区间加入结果列表。
遍历区间列表，对于每个区间 [start, end]：
- 如果当前区间与结果列表中的最后一个区间重叠（即 start <= result.get(result.size() - 1).end），则合并区间，更新结果列表中最后一个区间的结束位置为 Math.max(end, result.get(result.size() - 1).end)。
- 否则，将当前区间加入结果列表。
返回结果列表。

4. 代码实现（Java）

import java.util.*;

public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        if (intervals.size() == 0) {
            return new ArrayList<>();
        }
        Collections.sort(intervals, (a, b) -> a.start - b.start);
        List<Interval> result = new ArrayList<>();
        result.add(intervals.get(0));
        for (int i = 1; i < intervals.size(); i++) {
            Interval last = result.get(result.size() - 1);
            if (intervals.get(i).start <= last.end) {
                last.end = Math.max(last.end, intervals.get(i).end);
            } else {
                result.add(intervals.get(i));
            }
        }
        return result;
    }
}

5. 复杂度分析

时间复杂度 ：O(n log n)，其中 n 是区间列表的长度。排序的时间复杂度为 O(n log n)，遍历的时间复杂度为 O(n)。
空间复杂度 ：O(1)，我们只使用了常数级别的额外空间（不包括结果列表）。

三、轮转数组

1. 题目描述

给定一个数组 nums 和一个整数 k，将数组向右轮转 k 步，其中 k 是非负数。

2. 示例

示例 1：

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

输出：[5, 6, 7, 1, 2, 3, 4]

解释：向右轮转 3 步，得到 [5, 6, 7, 1, 2, 3, 4]。

3. 解题思路

这道题主要考察数组的操作。我们可以使用反转数组的方式来实现轮转。具体步骤如下：

计算实际轮转次数 k = k % nums.length，避免多余的轮转。
反转整个数组。
反转前 k 个元素。
反转剩余的 nums.length - k 个元素。

4. 代码实现（Java）

public class Solution {
    public void rotate(int[] nums, int k) {
        k = k % nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
}

5. 复杂度分析

时间复杂度 ：O(n)，其中 n 是数组的长度。我们只需要遍历数组三次，每次遍历的时间复杂度都是 O(n)。
空间复杂度 ：O(1)，我们只使用了常数级别的额外空间。

四、除自身以外数组的乘积

1. 题目描述

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

2. 示例

示例 1：

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

输出：[24, 12, 8, 6]

解释：output[0] = 2 * 3 * 4 = 24，output[1] = 1 * 3 * 4 = 12，output[2] = 1 * 2 * 4 = 8，output[3] = 1 * 2 * 3 = 6。

3. 解题思路

这道题主要考察数组的操作和乘积的计算。我们可以使用两次遍历数组的方式来计算每个位置的乘积。具体步骤如下：

初始化一个结果数组 output，长度与 nums 相同。
第一次遍历数组，从左到右，计算每个位置左边所有元素的乘积，并存储到 output 中。
第二次遍历数组，从右到左，计算每个位置右边所有元素的乘积，并与 output 中的值相乘。
返回 output。

4. 代码实现（Java）

public class Solution {
    public int[] productExceptSelf(int[] nums) {
        int[] output = new int[nums.length];
        int left = 1;
        for (int i = 0; i < nums.length; i++) {
            output[i] = left;
            left *= nums[i];
        }
        int right = 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            output[i] *= right;
            right *= nums[i];
        }
        return output;
    }
}

5. 复杂度分析

时间复杂度 ：O(n)，其中 n 是数组的长度。我们只需要遍历数组两次，每次遍历的时间复杂度都是 O(n)。
空间复杂度 ：O(1)，我们只使用了常数级别的额外空间（不包括结果数组）。

五、缺失的第一个正数

1. 题目描述

给定一个未排序的整数数组 nums，找出最小的缺失正整数。

2. 示例

示例 1：

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

输出：3

解释：最小的缺失正整数是 3。

3. 解题思路

这道题主要考察数组的操作和哈希表的应用。我们可以使用哈希表来记录数组中出现的正整数，然后从 1 开始遍历，找到第一个未出现在哈希表中的正整数。具体步骤如下：

初始化一个哈希表 set，用于存储数组中出现的正整数。
遍历数组，将所有正整数加入哈希表。
从 1 开始遍历，检查每个正整数是否在哈希表中存在，如果不存在，则返回该正整数。
如果所有正整数都存在，则返回 nums.length + 1。

4. 代码实现（Java）

import java.util.HashSet;
import java.util.Set;

public class Solution {
    public int firstMissingPositive(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int num : nums) {
            if (num > 0) {
                set.add(num);
            }
        }
        for (int i = 1; i <= nums.length; i++) {
            if (!set.contains(i)) {
                return i;
            }
        }
        return nums.length + 1;
    }
}