第二天|数组| 977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II

目录

977.有序数组的平方 

209.长度最小的子数组

59.螺旋矩阵II

---

977.有序数组的平方 

977自己做的方法1想到的是暴力解法，又看到提示说建议用双指针，就想到了Day1中的快慢指针，所以进行了求解，总体运行下来时间复杂度要比方法2高。

class Solution {
        public int[] sortedSquares(int[] nums) {
//            方法1_fff：暴力+快慢指针
//            int temp;
//            int fast , slow = 0;
//            先平方，后排序
//            for (int i = 0; i < nums.length; i++) {
//                nums[i] = nums[i] * nums[i];
//            }
//          nums[slow]是更新后的数组   nums[fast]触发更新条件
//            for (int i = 0; i < nums.length - 1; i++) {
//            得到的fast是最小值的index
//            应该把nums[fast]赋值给nums[slow]
//                fast = i;
//                for (int j = i + 1; j < nums.length; j++) {
//                    if (nums[fast] > nums[j]) {
//                        fast = j;
//                    }
//                }
//                temp = nums[slow];
//                nums[slow] = nums[fast];
//                nums[fast] = temp;
//                slow++;
//            }
//            return nums;
//            方法2：左右双指针
            int k = nums.length - 1;
            int[] result = new int[nums.length];
            for (int i = 0, j = nums.length - 1; i <= j; ) {
                if (nums[i] * nums[i] < nums[j] * nums[j]) {
                    result[k--] = nums[j] * nums[j];
                    j--;
                }else {
                    result[k--] = nums[i] * nums[i];
                    i++;
                }
            }
            return result;
        }
    }

209.长度最小的子数组

自己尝试-->失败

如图所示，目前并不清楚为什么这个测试用例的期望结果是8，我测出来感觉[28,83,25,26,25,25,25]这个子数组是符合题目要求的，因此输出为7。

思路：看到209的时候我的思路是在nums中找出1个小于target的最大值max，然后继续找<=nums-max中的最大值，依次找，并且在nums中将找出来max后的对应的nums[i]=0。

失败原因找到了：子数组需要是连续的，如果没有这个要求应该没问题。

下次审题再认真点。

下面附上自己尝试的代码：

class Solution {
        public int minSubArrayLen(int target, int[] nums) {
//        nums中找出1个最大值max,然后继续找<=nums-max中的最大值，依次找
            int result = 0;
            int n = 0;

            while (result < target) {
                int i;
                int index = 0;
                int max = nums[0];
                for (i = 1; i < nums.length; i++) {
                    if (nums[i] > target) {
                        nums[i] = 0;
                    }

                    if (max < nums[i]) {
                        max = nums[i];
                        index = i;
                    }
                }
                nums[index] = 0;
                if (max != 0) {
                    result = result + max;
                    n++;
                }
                if (n == nums.length && result < target) {
                    return 0;
                }

            }
            return n;
        }
    }

学习了视频讲解，以及理解了滑动窗口后，下面是能正常运行的代码：

主要思路是将暴力方法中的两个for循环用一个滑动窗口的方法，通过调节起止位置和终止位置来用一个for循环进行实现，降低复杂度。

    class Solution {
        public int minSubArrayLen(int target, int[] nums) {
//            滑动窗口法
//            滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出想要的结果。
//            难点在于只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。
//            难点2是如何移动滑动窗口的起始位置
            int i = 0;
            int sum = 0;
            int sublen;
            int result = Integer.MAX_VALUE;
            for (int j = 0; j < nums.length; j++) {
                sum = sum + nums[j];
                while (sum >= target) {
                    sublen = j - i + 1;
                    result = result > sublen ? sublen : result;
                    sum = sum - nums[i];
                    i++;
                }
            }
            return result == Integer.MAX_VALUE ? 0 : result;

        }
    }

59.螺旋矩阵II

59这个题第一次看到的时候是没有思路的，尝试了一下做不出来，就去看了题解。

重点思路：循环不变量，控制绕圈的每条边的区间都是左闭右开。

    class Solution {
        public int[][] generateMatrix(int n) {
            int startx = 0, starty = 0, offset = 1, count = 1;
            int i = 0, j = 0;
            int loop = 1; // 记录当前的圈数
            int[][] matrix = new int[n][n];
            while (loop <= n / 2) {
                // 左闭右开(循环不变量)
                // 顶部
                for (j = starty; j < n - offset; j++) {
                    matrix[startx][j] = count++;
                }
                // 右列
                for (i = starty; i < n - offset; i++) {
                    matrix[i][j] = count++;
                }
                // 底部
                for (; j > starty; j--) {
                    matrix[i][j] = count++;
                }
                // 左列
                for (; i > startx; i--) {
                    matrix[i][j] = count++;
                }
                startx++;
                starty++;
                offset++;
                loop++;

            }
            // n 为奇数时，单独处理矩阵中心的值
            if (n % 2 == 1) {
                matrix[startx][starty] = count;
            }

            return matrix;
        }
    }

第二天的总算是结束了，直冲Day3！