DAY2-数组，螺旋矩阵，977，209，59，剑指29

写在前面，剑指offer29和leetcode54类型是一样的，代码基本差不多。

977

思路：看到题目想不出来双指针法，只想到暴力破解，时间复杂度为O(n+nlog(n))，符合题目要求。因为刚好Arrays里有排序的方法，它的时间复杂度为O(nlog(n))。

public int[] sortedSquares(int[] nums) {
        for(int i=0;i<nums.length;i++){
            nums[i]=(nums[i])*(nums[i]);
        }
        Arrays.sort(nums);
        return nums;
    }

双指针法：不用自带的排序方法，用两个指针，平方之后把两个指针放在两头，开始比较，左边比右边小了就放入右边的下一个，有个问题，这样应该要开辟新数组空间，思路上还是不太对。看了解析，大致是正确的，只不过是左右相比大的放新开出来的结果集数组里，同时指针移动，时间复杂度为O(n)。

public int[] sortedSquares(int[] nums) {
       int[] res = new int[nums.length];
       int left=0;
       int right=nums.length-1;
       for(int i=nums.length-1;i>=0;i--){     
        if((nums[right])*(nums[right])>(nums[left])*(nums[left])){
            res[i]=nums[right]*nums[right];
            right--;
        }else{
            res[i]=nums[left]*nums[left];
            left++;
        }
       }
       return res;
    }

209

总感觉有两层，外层控制左边指针移动，内层控制右边指针移动，既然要找最小连续长度，就设一个最大的值作为flag，具体写不出来，循环体内代码逻辑捋不顺。

看了解析，是陷入了暴力破解的怪圈了，用滑动窗口双指针，想好一层for循环表示的是起始位置还是终止位置，如果是起始位置，那终止位置又怎么表示，所以for循环表示的肯定是终止位置。

public int minSubArrayLen(int target, int[] nums) {
        int res=Integer.MAX_VALUE;
        int sum=0;
        int left=0;
        for(int right=0;right<nums.length;right++){
            sum=sum+nums[right];
            while(sum>=target){
                res=Math.min(res,right-left+1); 
                sum=sum-nums[left];
                left++;
            }
        }
        return res==Integer.MAX_VALUE?0:res;
    }

不太明白的一个点是>=为什么可以合在一起。稍后再议.

另外，时间复杂度主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

 59

知道本题要用区间的定义，左闭右开，但具体怎么传进去还是没有什么思路。之前做过只有个模糊的影子。

不涉及算法，就是模拟过程，考察对代码的掌握能力，这是现在最欠缺的。

public int[][] generateMatrix(int n) {
        int l=0,r=n-1,t=0,b=n-1;
        int[][] res=new int[n][n];
        int num=1,tar=n*n;
        while(num<=tar){
            for(int i=l;i<=r;i++){
                res[t][i]=num++;               
            }
            t++;
            for(int i=t;i<=b;i++){
                res[i][r]=num++;                
            }
            r--;
            for(int i = r;i>=l;i--){
                res[b][i]=num++;                
            }
            b--;
            for(int i=b;i>=t;i--){
                res[i][l]=num++;                 
            }
            l++;
        }
        return res;
    }

看的是题解里一位大佬的解析，不知道为啥，for循环里的num++放在下一行num=num+1就会超时，有点子离谱。上面代码也不涉及什么左闭右开的，类似左闭右闭，先把循环到的一行上面能填满的都填满。

方法二：严格左闭右开

public int[][] generateMatrix(int n) {
        int[][] res=new int[n][n];
        int startx=0,starty=0;
        int offset=1,count=1;
        int i,j;
        while(n/2>0){
            for(j=starty;j<n-offset;j++){
                res[startx][j]=count++;
            }
            for(i=startx;i<j;i++){
                res[i][j]=count++;
            }
            for(;j>starty;j--){
                res[i][j]=count++;
            }
            for(;i>startx;i--){
                res[i][j]=count++;
            }
            offset++;
            startx++;
            starty++;
            n=n-2;
        }
        if(n%2==1){
            res[startx][starty]=count;
        }
        
        return res;
    }

剑指Offer 29 顺时针打印矩阵

在二维数组中，如果直接调用b.length方法，返回的则是b数组的行数，

如果是b[0].length方法则返回的是0行所代表的长度。

思路：是跟螺旋矩阵一样的，唯一的是这个长宽不一定一致，输出到最后得判断，肯定最后一步不是向右就是向下。

public int[] spiralArray(int[][] array) {
        int ilength=array.length;
        int jlength=array[0].length;
        int length=ilength*jlength;
        int[] res=new int[length];
        int startx=0,starty=0;
        int index=0;
        int offset=1;
        int n=Math.min(ilength,jlength);
        int i,j;
        while(n/2>0){
            for(j =starty;j<jlength-offset;j++){
                res[index++]=array[startx][j];
            }
            for(i=startx;i<ilength-offset;i++){
                res[index++]=array[i][j];
            }
            for(;j>starty;j--){
                res[index++]=array[i][j];
            }
            for(;i>startx;i--){
                res[index++]=array[i][j];
            }
            startx++;
            starty++;
            offset++;
            n=n-2;
        }
        if(n%2==1){
             if(ilength>jlength){
                for(i=startx;i<=ilength-offset;i++)
                res[index++]=array[i][starty];
            }else if(ilength<jlength){
                for(j=starty;j<=jlength-offset;j++){
                    res[index++]=array[startx][j];
                }
            }else{
                res[index]=array[startx][starty];
            }
        }
    }

注意的就是循环之后if里面的逻辑，之前的都是左闭右开，判断时不加等号老会漏掉最后一个值。

这道题从2/27->18->27->4/27->24/27->27/27，太心酸了，最后就是一个等号。

写在后面：还是得多做模拟类的题锻炼自己的代码意识。