day02| 有序数组的平方、长度最小的子数组、螺旋矩阵||

目录

有序数组的平方

 长度最小的子数组

螺旋矩阵|| 

---

有序数组的平方

题目链接：977. 有序数组的平方

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

暴力思路：直接对数组每个数先进行平方，然后输出排序后的数组。

时间复杂度O(n*longn),力扣上耗时5ms

空间复杂度O(n)

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i = 0; i < nums.length; i++)
            nums[i] = nums[i] * nums[i];
        Arrays.sort(nums);
        return nums;
    }
}

 双指针思路：数组其实是有序的， 只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l = 0;
        int r = nums.length - 1;
        int[] res = new int[nums.length];
        int j = nums.length - 1;
        while(l <= r){
            if(nums[l] * nums[l] > nums[r] * nums[r]){
                res[j--] = nums[l] * nums[l++];
            }else{
                res[j--] = nums[r] * nums[r--];
            }
        }
        return res;
    }
}

 另一种与之相反的思路：

前者是直接找最大平方数，次大平方数...，是从最左和最右开始遍历；其实我们也可以从中间开始遍历，直接找最小数，倒数第二小的数...，之后再将没遍历完的数再加进来即可

关键就是找到最接近0的数的下标，然后从该下标向两边遍历数组求较小值

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] res = new int[nums.length];
        int index0 = getIndex(nums);
        int index = 0;
        res[index] = nums[index0] * nums[index0];
        int left = index0 - 1,right = index0 + 1,lNum,rNum;
        while(left >=0 && right < nums.length){
            index++;
            lNum = Math.abs(nums[left]);
            rNum = Math.abs(nums[right]);
            if(lNum <= rNum){
                res[index] = lNum * lNum;
                left--;
            }else{
                res[index] = rNum * rNum;
                right++;
            }
        }
        while(right < nums.length){
            index++;
            rNum = Math.abs(nums[right]);
            res[index] = rNum * rNum;
            right++;
        }
        while(left >= 0){
            index++;
            lNum = Math.abs(nums[left]);
            res[index] = lNum * lNum;
            left--;
        }

        return res;
    }
    //找到0元素对应的下标，没有则返回离0元素最接近的元素的下标
    public int getIndex(int[] nums){
        int left = 0, right = nums.length - 1;
        while(left < right - 1){
            int mid = left + (right - left) / 2;
            if(nums[mid] == 0)return mid;
            else if(nums[mid] > 0)right = mid;
            else    left = mid;
        }
        if(Math.abs(nums[left]) <= Math.abs(nums[right]))return left;
        else    return right;
    }
}

 长度最小的子数组

题目链接：209. 长度最小的子数组

---给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 子数组

 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路：用滑动窗口的思路，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果

窗口的起始位置如何移动：如果当前窗口的值大于等于target了，窗口就要向前移动了（也就是该缩小了,left++）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum = 0, mLen = target + 1;
        int left = 0,right = 0,n = nums.length;
        while(right < n){
            sum += nums[right];
           //窗口关键！！ 
            while(sum >= target){
                mLen = Math.min(mLen,right - left + 1);
                sum -= nums[left];
                left++;
            }
            
            right++;
        }
        if(mLen == target + 1)return 0;
        return mLen;
    }
}

螺旋矩阵|| 

题目链接：59. 螺旋矩阵 II

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

思路：需要坚持固定规则来遍历，每一条边我们只填充n-1个点，例如n=3，那第一条边只填充1,2两个点[0,2)，第二条边填充3,4两个点...；这里我们遵循左闭右开的原则

模拟顺时针画矩阵的过程填充上行从左到右

• 填充右列从上到下
• 填充下行从右到左
• 填充左列从下到上

由外向内一圈一圈这么画下去。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];

        int startx = 0,starty = 0;//每一圈的起始点
        int offset = 1;// 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int count = 1;
        int ci = n / 2;//圈数
        int i,j;//i代表行，j代表列
        while(ci-- > 0){
            i = startx;
            j = starty;
            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }
            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;
            // offset 控制每一圈里每一条边遍历的长度
            offset++;
        }
        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if(n % 2 == 1){
            res[n / 2][n / 2] = n * n;
        }
        return res;
    }
}