代码随想录第二天|力扣977.有序数组的平方209.长度最小的子数组 59.螺旋矩阵II

第一题

977. 有序数组的平方

题目链接

思路：

还是可以采用双指针的思路来做，先考虑题意，要求返回由每个数字的平方组成的新数组，同时还要求非递减顺序排序。，那么我们可以考虑这个数组里面有负数，所以中间的平方不会比两边的都要大，所以我们设置两个左右指针，放在数组的两端向中间移动，然后每次比较两浮标指向的数的平法大小，同时我们已经知道数组的大小所以倒着存即可

空间复杂度： O（n）  ，时间复杂度  O（n）

Java

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

Python

print()

本题收获

第二题 螺旋矩阵 II

题目链接

思路：

模拟题，主要考察思路的严谨性，定义好不变量。这个题我这里分了两种情况，对于n为奇数的时候最后一次不符合定义的条件需要手动判断并返回一下

Java

class Solution {
    public int[][] generateMatrix(int n) {
        int num = 1;
        //横坐标
        int i=0;
        //纵坐标
        int j=0;
        // 上下左右边界
        int top = 0;
        int right = n -1;
        int left = 0;
        int bottom = n -1;
        // 生成矩阵
        int[][] matrix = new int[n][n];
        while(num <= (n*n)){
            // 对n为奇数时进行特判
            if (j==(n-1)/2&&i==j&&n%2==1){
                matrix[i][j]=n*n;
                break;
            }
            // 向右填入数字
            while(j < right){
                matrix[i][j] = num;
                num++;
                j++;
            }
            right--;
            // 向下填入数字
            while(i < bottom){
                
                matrix[i][j] = num;
                num++;
                i++;
            }
            bottom--;
            // 向左填入数字
            while(j>left){
               matrix[i][j] = num;
               num++;
               j--; 
            }
            left++;
            while(i > top){
                matrix[i][j] = num;
                num++;
                i--;
            }
            i++;
            top++;
            j++;
        }
        return matrix;
    }
}

Python

class Solution:
    def generateMatrix(self, n: int) -> [[int]]:
        l, r, t, b = 0, n - 1, 0, n - 1
        mat = [[0 for _ in range(n)] for _ in range(n)]
        num, tar = 1, n * n
        while num <= tar:
            for i in range(l, r + 1): # left to right
                mat[t][i] = num
                num += 1
            t += 1
            for i in range(t, b + 1): # top to bottom
                mat[i][r] = num
                num += 1
            r -= 1
            for i in range(r, l - 1, -1): # right to left
                mat[b][i] = num
                num += 1
            b -= 1
            for i in range(b, t - 1, -1): # bottom to top
                mat[i][l] = num
                num += 1
            l += 1
        return mat

第三题209. 长度最小的子数组

思路：

采用滑动窗口的思路，因为他要求的返回的是子数组，所以我们定义两个变量来保存这个滑动窗口的左端和右端，这里的难点在于中间不变量，要先确定我们这个right到底指向的是什么，是下一个要放入的子数组的位置，换是子数组中最后一位的位置。我这里right定义的为要放入子数组的位置是要放但还不在子数组当中。

Java

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int right = 0;
        int left = 0;
        int sum = 0;
        int ans = 1000000;
        while(right <= nums.length && right>=left){
            // System.out.println("right:"+right+" left:"+left+" ans:"+ans+" sum:"+sum);
            if (sum < target){
                if (right==nums.length){
                    break;
                }
                sum += nums[right];
                right++;
            }else if(sum >= target){
                if ( (right-left) < ans ){
                    ans= right-left;
                }
                sum -= nums[left];
                left++;
            }
        }
        if (ans != 1000000){
            return ans;
        }
        return 0;
    }
}

Python

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        n = len(nums)
        ans = n+1
        s=0
        left = 0 
        for right , x in enumerate(nums):
            s += x
            while s >= target:
                ans = min(ans,right-left+1)
                s -= nums[left]
                left += 1
        return ans if ans <= n else 0