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

977：有序数组的平方

这个题写了老半天，调了很久，一开始当然是想到直接把平方求出来，再排序，但是复杂度要求是O(n)，所以得考虑快排这样复杂度低的算法，排序算法有点记不清了，所以就想着换个思路。初识思路是想到昨天的移除元素用的双指针的方法，因为所给的数组是一个“按 非递减顺序 排序的整数数组”，那么进行平方之后就应该是最小值在中间，然后左右两遍的值比它大，每次选择左右两边两个元素的较小值作为下一个元素，如果左边的元素已经全部比完了，右边又是非递减的顺序，可以直接依次挪进去，如果右边的元素已经比完了，左边还有元素的话，按照逆序挪给新数组就行。最终还是AC了，不过在考虑边界问题上还是废了很多时间。

代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int len = nums.length;
        int[] squareNums = new int[len];
        int[] res = new int[len];
        for(int i=0;i<len;i++){
            squareNums[i] = square(nums[i]);
        }
        int min = squareNums[0];
        int minIndex = 0;
        for(int i=1;i<len;i++){
            if(squareNums[i]<min){
                min = squareNums[i];
                minIndex = i;
            }
        }

        
        int left = minIndex-1, right = minIndex+1;
        res[0]=squareNums[minIndex];
        int i = 1;
        while(i<len){
            if(left<0){//如果发现左边没有更小的，把右边搬过去就行
                for(int j=right;j<len;j++){
                        res[i] = squareNums[j];
                        i++;
                    }
            }else if(right>=len){//右边没有更小的，把左边逆序搬过去
                for(int j=left;j>=0;j--){
                        res[i] = squareNums[j];
                        i++;
                    }
            }else{
                if(squareNums[left]<squareNums[right]){
                    res[i] = squareNums[left];
                    left--;
                }else{
                    res[i] = squareNums[right];
                    right++;
                }
            }
            i++;
        }

        return res;
    }

    int square(int num){
        return num*num;
    }
}

后来看了题解，平方之后，较大值位于数组两端，依次向中间遍历，直到left>right时停止，这种方法的好处是就不用像我想的那种考虑边界条件。

代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int len = nums.length;
        int[] res = new int[len];
        int k=len-1;
        for(int left=0,right=len-1;left<=right;){
            if(nums[left]*nums[left]<nums[right]*nums[right]){
                res[k--] = nums[right]*nums[right];
                right--;
            }else{
                res[k--] = nums[left]*nums[left];
                left++;
            }
        }

        return res;
    }

}

209：长度最小的子数组

一开始没有什么好的思路，只想到的暴力解法，依次看n个连续的子数组之和是否大于等于target，时间复杂度太高！！！

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = nums.length;
        for(int n=1;n<=len;n++){
            for(int i=0;i<len-n+1;i++){
                if(getSum(nums,i,n)>=target){
                    return n;
                }
            }
        }
        return 0;
    }

    int getSum(int[] nums,int i, int n){
        int sum = 0;
        while(n>0){
            sum += nums[i++];
            n--;
        }
        return sum;
    }
}

题解：滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

通过不断调整子序列和起始位置和终止位置以实现一个for循环就可以找到所要的结果。（感觉好像精妙的算法可以实现对资源和时间的利用最大化）

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = nums.length;
        int begin=0,res=Integer.MAX_VALUE,sum=0,subLength;
        for(int end=0;end<len;end++){
            sum += nums[end];
            while(sum>=target){
                subLength = end - begin + 1;
                res = res < subLength ? res:subLength;//原来的res比较小的话就是res，否则就是比res小的subLength
                sum -= nums[begin++];
            }
        }
        return res == Integer.MAX_VALUE? 0 : res;
    }

}

59：螺旋矩阵||

最开始看到这个题目的时候还在想到底元素和下标之间有什么规律，尝试了很久也没找到规律，想着总不能真的要像砌墙一样慢慢赋值吧，看了题解之后发现还真是。于是就自己开始慢慢写，最开始还不知道里层是如何变化的，先写了最外层，然后一层一层深入，思路也慢慢打开了。有时候把思路实现为算法感觉有点难以下手，这时候先写着试试，逐渐也就有思路了，最后再优化debug一下差不多就ac了。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];
        int k = 1;
        int q = (n+1)/2;
        for(int j=0;j<q;j++){
            for(int i=j;i<n-j;i++,k++){
                res[j][i] = k;
            }
            for(int i=1+j;i<n-j;i++,k++){
               res[i][n-1-j]=k;
            }
            for(int i=n-2-j;i>=j;i--,k++){
              res[n-1-j][i]=k;
            }
            for(int i=n-2-j;i>j;i--,k++){
            res[i][j]=k;
        }
        }

        return res;
    }
}

总结：今天对双指针减少算法复杂度加深了理解，算法实现好像也熟练了很多。希望之后继续加油。