代码随想录day02：977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵

977.有序数组的平方
思路：一开始想的是找到0的位置，再从0用双指针往左和往右找较小值。时间复杂度也是O(n),但要考虑全为正或者全为负的情况，代码逻辑也不够简洁。
代码随想录讲解
应该想到数据集的特性，就好比，二分查找的前提是有序，（重复元素的话会导致查找下标不唯一），这个数据的特性就是从小到大排复杂，从大到小排方便，每次的最大平方值一定在数据集两端取得。

数组其实是有序的， 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
此时可以考虑双指针法了，i指向起始位置，j指向终止位置。
定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int []anr=new int[nums.length];
        int left=0;
        int right=nums.length-1;
        int i=nums.length-1;
        while(left<=right){
            int leftNum=nums[left]*nums[left];
            int rightNum=nums[right]*nums[right];
            if(leftNum>rightNum){
                anr[i--]=leftNum;
                left++;
            }
            else{
                anr[i--]=rightNum;
                right--;
            }
        }
        return anr;
    }
}

209.长度最小的子数组
思路：两个指针，记录慢指针与快指针之间的元素之和sum，每当sum大于等于target时，慢指针移动，sum减去当前慢指针所指向的元素，直到sum小于target，再继续移动快指针。代码如下：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //定义快慢指针
        int left=0,right=0;
        //定义多个连续元素之和
        int sum=0;
        //定义子数组的长度
        int length=0;
        //移动快指针，连续元素相加
        for(;right<nums.length;right++){
            //如果连续元素之和大于等于target，记录当前长度，减少慢指针所指向的当前元素值，移动慢指针
            while(sum>=target){
                int temp=right-left;
                //当temp<length时或者length==0时，记录length=temp
                if(temp<length||length==0)length=temp;
                sum=sum-nums[left++];
            }
            //如果连续元素之和小于target，移动快指针，sum加上快指针所指向的元素
            sum=sum+nums[right];
        }
        //最后当right到达数组末尾时，nums[right]会越界，所以将移动慢指针的步骤再执行一次
        while(sum>=target){
            int temp=right-left;
            if(temp<length||length==0)length=temp;
            sum=sum-nums[left++];
        }
        return length;
    }
}

代码随想录讲解
滑动窗口思想
不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。
一开始我想的那种就是滑动窗口的思想，但是代码不够规范，而且是在滑动之后加入新元素，所以最后循环结束后还得再加一次滑动

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //滑动窗口起始位置和结束位置
        int left=0,right=0;
        //滑动窗口数值之和
        int sum=0;
        //滑动窗口的长度
        int length=0;
        //移动快指针，连续元素相加
        for(;right<nums.length;right++){
            //移动快指针，sum加上快指针所指向的元素
            sum=sum+nums[right];
            // 注意这里使用while，每次更新 left（起始位置），并不断比较子序列是否符合条件
            while(sum>=target){
                //取子序列的长度
                int temp=right-left+1;
                //当temp<length时或者length==0时，记录length=temp
                //如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
                if(temp<length||length==0)length=temp;
                //这里体现出滑动窗口的精髓之处，不断变更left（子序列的起始位置）
                sum=sum-nums[left++];
            }
        }
        return length;
    }
}

59.螺旋矩阵
思路：第一时间没想出来怎么螺旋输入数据。
代码随想录讲解
坚持循环不变量原则。

模拟顺时针画矩阵的过程:
填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上
可以发现这里的边界条件非常多，在一个循环中，如此多的边界条件，如果不按照固定规则来遍历，那就非常复杂。
每画一条边都要坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。
我自己按照左闭右开的方式写出来了，但是奇数时最中间的数还是需要在循环外添加进数组。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] anr=new int[n][n];
        int i=1;
        //一共循环n-1次
        for(int m=0;m<n-1;m++){
            //从左往右
            for(int j=m;j<n-m-1;j++){
                anr[m][j]=i++;
            }
            //从上往下
            for(int j=m;j<n-m-1;j++){
                anr[j][n-m-1]=i++;
            }
            //从右往左
            for(int j=n-m-1;j>m;j--){
                anr[n-m-1][j]=i++;
            }
            //从下往上
            //行变列不变，行从下往上
            for(int j=n-m-1;j>m;j--){
                anr[j][m]=i++;
            }
        }
        if(n%2!=0){
            int core=n/2;
            int max=n*n;
            anr[core][core]=max;
        }
        return anr;
    }
}

正确的循环次数是n/2；要理解循环多少圈，每循环一圈，边减少2，所以是n/2，我自己写成了n-1次，虽然也ac了。。。。

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        int i, j;

        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            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 == 1) {
            res[start][start] = count;
        }

        return res;
    }
}

数组总结：

数组下标都是从0开始的。
数组内存空间的地址是连续的
数组可以看作顺序表，数组的空间在申请时就分配好了，不能修改，数组的数据只能覆盖，不能删除。
二分法：循环不变量原则，在循环中搞清楚区间的定义，左闭右闭，target在区间内包括两个端点，左闭右开，target在区间内不包括右端点，相当于右边加了个头节点，区间的定义与二分时根据mid确定新区间息息相关。

双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

滑动窗口：根据当前子序列和大小的情况，不断调节子序列。

模拟行为：循环不变量原则每次循环的意义，最好是先把循环的主体确定，然后主体中每个行为的变化搞清楚。

自我感觉：方法写成代码好写，但一看到题，不容易想清楚怎么将合适的方法运用，比如有序数组的平方一题中，想到了用双指针从小到大排，就很麻烦，但是若从大往下排，就很方便，因为原数组也是有序的，就算有负数，最大的平方值，也一定在原数组的两端取得。