力扣算法 209.长度最小的子数组 977.有序数组的平方 59.螺旋矩阵

学习目标：

力扣算法

209.长度最小的子数组

977.有序数组的平方

59.螺旋矩阵

学习内容：

209.长度最小的子数组

移动窗口的解法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //从头开始
    	int left = 0;
    	int result = Integer.MAX_VALUE;
    	int sum = 0;
    	for(int j = 0;j < nums.length;j++){
    		sum+=nums[j];
    		//这里不只判断一次，而是判断多次，因此用while
    		//sum值已经大于target，这需要将left往后开始挪，缩小区间
    		while(sum >= target){
    			//取区间的最小值
    			result = Math.min(result,j-left+1);
    			//left往后移，一开始的sum要减去对应位置的值
    			sum-=nums[left++];
    		}
    	}
    	return result == Integer.MAX_VALUE ? 0:result;
    }
}

代码疑问解答

1、在for循环里为什么使用while而不使用if？

到了这一步已得出前面已知的元素相加的和是大于目标值的，为了求得最小的区间，需不断减去前面的元素，以此求得区间最小且大于目标值的数组长度

977.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 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]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

双指针解法

class Solution {
     public int[] sortedSquares(int[] nums){
    	/*题目一开始是有序的，且存在正负，则存在最前面的数或者最后面的数平方后最大的情况。
    	因此可以用双指针分别指向最前和最后两个位置的元素，再不断缩小区间进行比较*/
		int left = 0;
		int right = nums.length-1;
		int num[] = new int[nums.length];
		//设置一个变量表示从后往前插入
		int leng = nums.length-1;
		while(left <= right){
			int leftnum = nums[left]*nums[left];
			int rightnum = nums[right]*nums[right];
			if(leftnum > rifhtnum){
				num[leng--]=leftnum;
				left++;
			}else{
				num[leng--]=rightnum;
				right--;
			}
		}
		return num;
    }
}

代码疑问解答

1、为什么新数组从后往前插入？

由于题目给出数组是递增顺序，且有正负号，因此无论是是第一个元素还是最后一个元素，平方之后两者比较大小判断出来的数都会是最大的，因此从后插入，依次类推

59.螺旋矩阵

class Solution {
    //通过画图可知，使用循环不变量，左闭右开的区间
    public int[][] generateMatrix(int n) {
            // 创建二维数组存储
    	    int nums[][] = new int[n][n];
            //该变量代表圈数
			int loop = n/2;
			//改变量代表初始位置
			int start = 0;
			//改变量代表插入的数值
			int count = 1;
			//该变量代表每循环一圈，需要减少的边界值
			int offset = 1;
			//两个变量分别代表矩阵的相应位置
			int i,j;
			//循环的条件
			while(loop > 0){
				for(j = start;j < n-offset;j++){
					nums[start][j]=count++;
				}
				for(i = start;i < n-offset;i++){
					nums[i][j]=count++;
				}
				//注意边界值
				for(;j > offset - 1;j--){
					nums[i][j]=count++;
				}
				for(;i > offset - 1;i--){
					nums[i][j]=count++;
				}
				//进行第二圈
				loop--;
				start++;
				offset++;
			}
			if(n%2 == 1){
				nums[start][start] = count;
			}
			return nums;
		}
    }
}

代码疑问解答

1、为什么要设置那么多的变量？

由于题目是求螺旋矩阵，是绕圈进行，每增加一圈，相关变量就需要改变

2、为什么要依照循环不变量的原则？

遵循循环不变量原则，即坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。

图片理解

复习

977. 有序数组的平方

第一次写存在错误：
即右指针不一定就会比左指针的下一个树更大，把逻辑写死了
且我们先找的是最大值 要从后往前放

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] num = new int[nums.length];
        int i= 0;
        int j = nums.length-1;
        int k = 0;
        while(i < j){
            int left = nums[i];
            int right = nums[j];
            //逻辑存在错误：
            //即右指针不一定就会比左指针的下一个树更大，把逻辑写死了
            //且我们先找的是最大值 要从后往前放
            if(left*left > right*right){
                num[k++] = left*left;
                num[k++] = right*right;  
            }else{
                num[k++] = right*right;  
                num[k++] = left*left;
            }
            i++;
            j--;
        }
        return num;
    }
}

矫正后：

class Solution {
     public int[] sortedSquares(int[] nums){
		int left = 0;
		int right = nums.length-1;
		int num[] = new int[nums.length];
		//设置一个变量表示从后往前插入
		int leng = nums.length-1;
		while(left <= right){
			int leftnum = nums[left]*nums[left];
			int rightnum = nums[right]*nums[right];
			if(leftnum > rifhtnum){
				num[leng--]=leftnum;
				left++;
			}else{
				num[leng--]=rightnum;
				right--;
			}
		}
		return num;
    }
}

209.长度最小的子数组

第一次写存在错误：
函数错误、逻辑错误

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i = 0;
        int sum = 0;
        //函数写错
        int result = Math.MAX_VALUE;
        for(int j = 1;j < nums.length;j++){
            sum += nums[i]+num[j];
            if(sum >= target){
            		//位置写错
                result = Math.MIN_VALUE(result,j-i);
                i++;
            }
        }
        return result;
    }
}

矫正后：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //从头开始
    	int left = 0;
    	int result = Integer.MAX_VALUE;
    	int sum = 0;
    	for(int j = 0;j < nums.length;j++){
    		sum+=nums[j];
    		//这里不只判断一次，而是判断多次，因此用while
    		//sum值已经大于target，这需要将left往后开始挪，缩小区间
    		while(sum >= target){
    			//取区间的最小值
    			result = Math.min(result,j-left+1);
    			//left往后移，一开始的sum要减去对应位置的值
    			sum-=nums[left++];
    		}
    	}
    	return result == Integer.MAX_VALUE ? 0:result;
    }
}