数组刷题(2)

1. 有序数组的平方

1.1暴力法

这里直接对数组中元素进行平方，然后采用排序算法（调用了快速排序算法）进行求解，所以它的时间复杂度即是排序算法的复杂度nlog(n)，其实应该把快排再写一遍，加深印象，而不是直接调用。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int size=nums.size();
        for(int i=0;i<nums.size();i++)
        {
            nums[i]=nums[i]*nums[i];
        }
        sort(nums.begin(),nums.end());
        return nums;
    }
};

1.2采用双指针法

为了减少时间复杂度，采用双指针法，一个指针在头部（i），一个在尾部（j），进行头部值平方和尾部值平方比较，然后将其赋值给新数组，新数组的下标变量为k，每比较完一次，新数组下标k--，原数组的i++或者j--进行变化，需要注意的是i<=j，如果仅仅是i<j就会把i=j时候的元素在新数组中丢失，如下：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> nums(A.size(),0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j
            if (A[i] * A[i] < A[j] * A[j])  {
                nums[k--] = A[j] * A[j];
                j--;
            }
            else {
                nums[k--] = A[i] * A[i];
                i++;
            }
        }
        return nums;
    }
};

2.长度最小子数组

2.1暴力法

执行的时候超出时间限制了，一开始写的时候忘记写sum=0（每次都要sum=0开始），还有break（每一轮找到之后，再继续向下len1没有意义），这里采用两个for循环，其实是想把所有情况都遍历出来，

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum=0;
        int len=0;
        int len1=INT32_MAX;
        for(int i=0;i<nums.size();i++)
        {
            sum=0;
            for(int j=i;j<nums.size();j++)
            {
                sum=sum+nums[j];
                if(sum>=target)
                {
                    len=j+1-i;
                    len1=len1<len?len1:len;
                    break;
                }
            }
        }
        return len1==INT32_MAX?0:len1;
    }
};

2.2采用滑窗

忽然忘了之前的方法，其实主要思想是首先进行数组遍历从i=0开始找到一个满足初始的sum>=target的一个区间，然后开始做减法，依次减去从j=0开始的元素，直到sum<target,然后再继续遍历剩余没有遍历过的元素，这样做的目的就是要遍历整个数组，通过区间的变化来找到一个最小长度的区间

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        
        int len=0;
        int sum=0;
        int j=0;
        int len1=INT32_MAX;
        for(int i=0;i<nums.size();i++)
        {
            sum=sum+nums[i];
            while(sum>=target)
            {
                len=i+1-j;
                len1=len<len1?len:len1;
                sum=sum-nums[j];
                j++;
            }
        }
        return len1==INT32_MAX?0:len1;
    }
};

2. 螺旋数组

首先lop=n/2是因为每一圈相当于是一个正方形，转一圈，那么左右两条，上下两条边就没了，相当于就是左边，右边，上边，下边各少了长度为1的边，因此转一圈，n的长度就要减2，所以是n/2，如果是奇数，那么最后的那个中间位置就要单独进行赋值。其次再进行转圈的过程中，我们要保证取每一条边的规则都是一样的，即上边、右边、下边、左边都是左闭右开，每一卷转完，offset都要加1，每一条边长度减少1，count是将数字从1-n*n赋值给数组每一个位置。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> num(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx=0;
        int starty=0;
        int offset=1;
        int count=1;
        int lop=n/2;
        int mid=n/2;
        int j;
        int i;
        while(lop--)
        {
            for(j=starty;j<n-offset;j++)
            {
                num[startx][j]=count;
                count++;
            }
            for(i=startx;i<n-offset;i++)
            {
                num[i][j]=count;
                count++;
            }
            for(;j>starty;j--)
            {
                num[i][j]=count;
                count++;
            }
            for(;i>startx;i--)
            {
                num[i][j]=count;
                count++;
            }
            offset++;
            startx++;
            starty++;
        }
        if(n%2)
        {
            num[mid][mid]=count;
        }
        return num;

    }
};