代码随想录刷题第2天

气氛组阿宇

已于 2023-01-12 23:54:49 修改

阅读量294

点赞数

文章标签： leetcode 算法职场和发展

于 2023-01-12 23:53:01 首次发布

本文链接：https://blog.csdn.net/Bi11y/article/details/128668199

版权

代码随想录刷题第2天

977. 有序数组的平方 - 力扣（LeetCode）

class Solution {
public:
/*
    void    my_swap(int &a, int &b){
        int tmp ;
        tmp = a;
        a = b ;
        b = tmp;
    }
*/
    vector<int> sortedSquares(vector<int>& nums) {
        int slow = 0;
        int fast = nums.size()-1;
        vector<int> new_nums(fast+1,0);
        int finish = fast;
        while(slow <= fast){
            int tmp1 = nums[slow] * nums[slow];
            int tmp2 = nums[fast] * nums[fast];
            if (tmp1 < tmp2){
                new_nums[finish--] = tmp2;
                fast--;
            }
            else if(tmp2 <= tmp1){
                //my_swap(nums[fast],nums[slow]);
                new_nums[finish--] = tmp1;
 
                slow++;
            }
 
 
        }
        return new_nums;
    }
};

要新建一个存储结果的vector容器，然后利用双指针处理，当无法找到最小的时候，去找最大的放进去，然后返回新建的数组就可以了

第一遍没有想到新建容器，企图利用交换在一个数组中处理，来节约内存空间，但是交换之后会出现小的放在大的前面的情况，这点需要注意！！！！

209. 长度最小的子数组 - 力扣（LeetCode）

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

双指针的应用，要点是找到未处理的数组还有处理过的数组，两个指针分别指向它们，然后建立一个返回的长度即可，不要忘记没有大于的情况出现就好了

59. 螺旋矩阵 II - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
         vector<vector<int>> result(n,vector<int>(n,0));
        int loop = n / 2;
        int startx = 0, starty = 0;
        int mid = n / 2;
        int count = 1;
        int offset = 1;
        int i= 0  ,j = 0 ;
        while (loop--)
        {
            //从左到右
            for (i = startx; i < n - offset; i++)
            {
                result[starty][i] = count;
                count++;
            }
            
            //从上到下
            for ( j = starty; j < n - offset; j++)
            {
                result[j][i] = count;
                count++;
            }
            
            //从右到左
            for ( ; i > startx; i--)
            {
                result[j][i] = count;
                count++;
            }
            
            //从下到上
             for ( ; j > starty; j--)
            {
                result[j][i] = count;
                count++;
            }
            startx++;
            starty++;
            offset++;

        }
        

        if (n % 2)
        {
            result[mid][mid] =  n * n ;
        }
        
        return result;
    }
};