Day 02

Day 02

977.有序数组的平方

暴力排序

先平方，再排序

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        for i in range(len(nums)):
            nums[i] = nums[i] ** 2

        nums.sort()
        return nums

双指针法

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

python

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        left = 0
        right = len(nums) - 1
        i = len(nums) - 1
        res = [float('inf')] * len(nums)
        while left <= right:
            if nums[left] ** 2 < nums[right] ** 2:
                res[i] = nums[right] ** 2
                right -= 1  
            else:
                res[i] = nums[left] ** 2
                left += 1
            i -= 1
        return res

注：需要新的列表存放平方后的结果。

Java

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int i = nums.length - 1;
        int[] res = new int[nums.length];  // Java中的列表形式
        while(left <= right){
            if(nums[left] * nums[left] < nums[right] * nums[right]){
                res[i] = nums[right] * nums[right];
                --right;
            }
            else{
                res[i] = nums[left] * nums[left];
                ++left;
            }
            --i;
        }
        return res;
    }
}

注：int[] res = new int[nums.length]; // Java中的列表形式。

–right;++left与python中的表示区别。

209.长度最小的子数组

滑动窗口

不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

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

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

代码思路：

左右都为零，设置一个累加值，先动右窗口，累加右窗口的值，当累加值大于目标值，判断最小长度和左右差谁小，减去左窗口的值，移动左窗口，移动右窗口。

python

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        left = 0
        right = 0
        add = 0
        min_len = float('inf')
        l = len(nums)

        while right < l:
            add += nums[right]

            while add >= target:
                min_len = min(min_len, right - left + 1)
                add -= nums[left]
                left += 1

            right += 1

        return min_len if min_len != float('inf') else 0 

Java

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        
        int l = nums.length;
        int sum = 0;
        int result = Integer.MAX_VALUE;  // int 类整数的最大值
        for(int right = 0; right < l; right++){
            sum += nums[right];
            while(sum >= target){
                result = Math.min(result, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result; // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列

    }
}

59.螺旋矩阵II

按顺序逻辑判断，存在多种写法，注意语句。

python

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        res = [[0] * n for _ in range(n)]
        starx = 0
        stary = 0
        loop = n // 2
        mid = n // 2
        count = 1

        for offset in range(1, loop + 1):
            for i in range(stary, n - offset):
                res[starx][i] = count
                count += 1
            for i in range(starx, n - offset):
                res[i][n - offset] = count
                count += 1
            for i in range(n - offset, stary, -1):
                res[n - offset][i] = count
                count += 1
            for i in range(n - offset, starx, -1):
                res[i][stary] = count
                count += 1
            starx += 1
            stary += 1

        if n % 2 != 0:
             res[mid][mid] = count
        return res

Java

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;
        int start = 0;
        int[][] res = new int[n][n];
        int count = 1;


        int i, j;

        while(loop++ < n / 2){
            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 != 0){
            res[start][start] = count;
        }
        return res;


    }
}