Leetcode刷题（数组）| 704. 二分查找；27.移除元素； 977. 有序数组的平方；209. 长度最小的子数组；59. 螺旋矩阵II

很早之前就已经了解到了代码随想录，也自己刷了一部分题，但一直没有认真完成过。现在马上秋招，打算按部就班地在重新刷一遍，同时也开个博客记录下来自己的理解，方便以后查看。

一、二分查找

Leetcode二分查找

使用二分查找最重要的是前提是数组必须有界。

此外还提到了一个思想叫做区间不变量：比如区间取左闭右闭的话，那么每次区间二分，范围都是新区间的左闭右闭 ，后面做判断时 ，要一直基于这个左闭右闭的区间。

二分法要注意边界问题：[left, right] 还是 [left, right) 。

二分法的时间复杂度是 O(logn)。

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

 二、移除元素

Leetcode移除元素

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

这里的快慢指针和上一题的左右指针不同，两者都是从下标为0开始的。

快指针：寻找那些不会被移除的元素，并赋给慢指针。

慢指针：接收来自快指针的数据，在接受到后自增一，移动到下一位。

class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        for (int right = 0; right < nums.length; right++) {
            if (nums[right] != val) {
                nums[left] = nums[right];
                left++;
            }
        }
    return left;
    }
}

三、有序数组的平方

Leetcode有序数组的平方

很重要的是，这是一个有序的序列。很明显，经过平方之后，负数会变为正数。在新的非递减序列中，排在后面的是值更大的元素，这个元素肯定是来自原数组的左右两侧的数据。

所以我们在原数组设立左指针和右指针，比较两者平方后的大小，将较大的那个赋给新数组的右侧，然后左右指针中被选中的那个自增或自减，新数组索引自减，再重复上述过程。

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

 四、长度最小的子数组

Leetcode长度最小的子数组

这道题返回的一个子数组，所以最重要的是，找到子数组的左右索引。要用到滑动窗口。

滑动窗口的右侧索引：这个索引遍历原数组直到末尾。

滑动窗口的左侧索引：当前窗口的值大于目标值了，就该缩小了。为什么可以缩小呢，因为原数组由正数构成，窗口减小一定会使和减小的。当缩小到第一次和小于目标值了，再缩小也一定会小于。

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

五、螺旋矩阵II

这东西挺费时间的，代码修修补补，搞不好就出了bug。

和二分法一样，注意左闭右开，在拐角处让给新的一条边来画。

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        int i, j;

        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }

            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }

            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }

        if (n % 2 == 1) {
            res[start][start] = count;
        }

        return res;
    }
}