代码随想录刷题笔记(数组)

1. 二分查找

代码随想录链接
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。假设 nums 中的所有元素是不重复的

    public static int binarySearch(int[] nums, int target) {
        //先确定查找的元素是否在数组范围里
        if (target < nums[0] || target > nums[nums.length - 1]) return -1;

        int bottom = 0;
        int top = nums.length - 1;
        int mid;
        do {
            mid = (bottom + top) >> 1;  //右移一位就相当于除2
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target) {
                bottom = mid + 1;
            } else {
                top = mid - 1;
            }
        } while (bottom <= top);
        return -1;
    }

2. 移除元素

代码随想录链接

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

不要使用额外的数组空间，你必须仅使用 $O(1)$ 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

    /**
     * 快慢指针求解, 时间复杂度O(n)
     * @param nums 传入数组
     * @param val 需要删除的元素
     * @return 执行删除操作后的数组长度
     */
    public static int removeElement(int[] nums, int val) {
        if (nums == null) return 0;  //判断传进来的数组是否为空
        int fast;
        int low;
        for (fast = 0, low = 0; fast < nums.length; fast++) {
            if (nums[fast] != val)  //不相等的时候才需要操作, 慢指针的位置赋值
                nums[low++] = nums[fast];  //赋值操作完成后慢指针+1
        }
        return low;  //注意返回值是否需要＋1或者-1
    }

3.有序数组的平方

代码随想录链接
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

    /**
     * 有序数组的平方
     * 没有要求原地操作就可以新建一个数组来存放比较后的数据
     * 平方后的数组一定是两边大中间小, 所以可以采用头尾双指针进行比较
     * 比较次数与元素个数是相同的, 每进行一次比较就确定一个元素
     * 因为排序是从小到大所以从后往前填补元素
     * 时间复杂度O(n)
     * @param nums 输入数组, 已排序
     * @return 返回平方后的排序数组
     */
    public static int[] sortedSquares(int[] nums) {
        if (nums == null) return null;
        int i;  //左指针
        int j;  //右指针
        int k;
        int[] vessel = new int[nums.length];
        for (i = 0, j = nums.length - 1, k = j; i <= j;) {  //头尾指针相遇后还会比较一次, 保证不会漏掉元素
            if (nums[i] * nums[i] > nums[j] * nums[j]) {
                vessel[k--] = nums[i] * nums[i];
                i++;
            } else {
                vessel[k--] = nums[j] * nums[j];
                j--;
            }
        }
        return vessel;
    }

4. 长度最小的子数组

代码随想录链接
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

    /**
     * 4.长度最小的子数组
     * 解法: 滑动窗口, 时间复杂度O(n)
     * @param target 子序列 >= target
     * @param nums 传入数组
     * @return 符合条件的子序列的最小长度
     */
    public static int minSubArrayLen(int target, int[] nums) {
        int i;  //左指针
        int j;  //右指针
        int min_length = nums.length;
        int length;
        int sum = 0;
        for (i = 0, j = 0; i <= j && j < nums.length; ) {
            if (sum + nums[j] >= target) {
                length = j -i +1;
                min_length = Math.min(min_length, length);
                sum -= nums[i++];  //窗口缩小
            }
            else {
                sum += nums[j++];  //窗口扩大
            }
        }
        if (i == 0) return 0;  //如果左指针i没有向右移动过就说明没有找到这样的连续序列
        return min_length;
    }

5. 螺旋矩阵Ⅱ

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

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

    /**
     * 5. 螺旋矩阵Ⅱ
     * 核心思想是一圈一圈依次填充四条边, 最外面一圈的边长是n - 1, 之后每一圈的边长-2
     * n为奇数时需要单独填充正中间的元素, 而且需要单独处理
     * @param n 边长
     * @return 输出n * n的螺旋矩阵
     */
    public static int[][] generateMatrix(int n) {
        int edge;  //每次填充一条边的长度
        int count;  //每一条边已经填充元素的个数
        int num = 1;  //待填充的数字
        int[][] matrix = new int[n][n];  //输出的螺旋矩阵
        int i, j;
        for (i = 0, j = 0, edge = n - 1; edge > 0; edge -= 2, i++, j++) {
            for (count = 0; count < edge; count++) {  //注意这里的判断条件是count"<"edge而不是"<="
                matrix[i][j++] = num++;
            }
            for (count = 0; count < edge; count++) {
                matrix[i++][j] = num++;
            }
            for (count = 0; count < edge; count++) {
                matrix[i][j--] = num++;
            }
            for (count = 0; count < edge; count++) {
                matrix[i--][j] = num++;
            }
        }
        if (n % 2 != 0) matrix[i][j] = num;
        return matrix;
    }