[数组] - 代码随想录（2-6）

1. 二分查找

给定一个 n 个元素有序（升序） 的整型数组 nums 和一个目标值 target，编写一个函数来查找 nums 中的 target。如果目标值存在，返回其下标；否则返回 -1。

java 复制代码

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length, left = 0, right = n - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2; // 避免溢出
            if (target < nums[mid]) {
                right = mid - 1;
            } else if (target > nums[mid]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }
}

说明：使用 mid = left + (right - left) / 2 是为了避免 left + right 可能导致的整数溢出问题。

2. 移除元素

给定一个数组 nums 和一个值 val，需要 原地移除所有等于 val 的元素，并返回移除后数组的新长度。

要求：

不得使用额外的数组空间；
仅使用 O(1) 的额外空间；
元素顺序可以改变；
不需要考虑数组中超出新长度的部分。

示例 1：

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

输出：2，且前两个元素为 2。

示例 2：

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

输出：5，且前五个元素为 0, 1, 3, 0, 4。

java 复制代码

class Solution {
    public int removeElement(int[] nums, int val) {
        int stackSize = 0;
        for (int num : nums) {
            if (num != val) {
                nums[stackSize++] = num;
            }
        }
        return stackSize;
    }
}

3. 有序数组的平方

给定一个按 非递减顺序 排序的整数数组 nums，返回一个由每个数字的平方组成的新数组，并要求该数组也按 非递减顺序 排列。

java 复制代码

class Solution {
    public int[] sortedSquares(int[] nums) {
        int n = nums.length, left = 0, right = n - 1, index = n - 1;
        int[] ans = new int[n];
        while (left <= right) {
            if (nums[left] * nums[left] < nums[right] * nums[right]) {
                ans[index--] = nums[right] * nums[right];
                right--;
            } else {
                ans[index--] = nums[left] * nums[left];
                left++;
            }
        }
        return ans;
    }
}

说明：利用双指针从两端向中间遍历，避免了先排序再平方的额外时间复杂度。

4. 长度最小的子数组

给定一个包含 n 个正整数的数组和一个正整数 s，找出满足其和 大于等于 s 的 最短连续子数组 ，并返回其长度。如果不存在符合条件的子数组，返回 0。

java 复制代码

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int ans = Integer.MAX_VALUE, left = 0, n = nums.length, sum = 0;
        for (int right = 0; right < n; right++) {
            sum += nums[right];
            while (sum >= target) {
                ans = Math.min(ans, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}

说明：使用滑动窗口法，时间复杂度为 O(n)，空间复杂度为 O(1)。

5. 螺旋矩阵

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素的正方形矩阵，且元素按 顺时针螺旋顺序 排列。

java 复制代码

class Solution {
    public int[][] generateMatrix(int n) {
        int t = 0, r = n - 1, b = n - 1, l = 0, num = 1, tar = n * n;
        int[][] ans = new int[n][n];
        while (num <= tar) {
            for (int i = l; i <= r; i++) {
                ans[t][i] = num++;
            }
            t++;
            for (int i = t; i <= b; i++) {
                ans[i][r] = num++;
            }
            r--;
            for (int i = r; i >= l; i--) {
                ans[b][i] = num++;
            }
            b--;
            for (int i = b; i >= t; i--) {
                ans[i][l] = num++;
            }
            l++;
        }
        return ans;
    }
}

说明：通过四条边依次填充，逐步缩小边界，实现螺旋填充。

总结

二分查找（高效查找）
移除元素（原地操作）
有序数组平方（双指针技巧）
最小子数组和（滑动窗口）
螺旋矩阵（边界控制）