代码随想录day 2刷题 数组 977 209 59

代码随想录day 2刷题 数组 977 |209 |59

题目：leetcode 977 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

题目分析：元素是非递减的，元素平方后也要按照非递减顺序。

思路：

1.暴力解法：将元素平方后，直接使用容器里的排序算法（ 复杂度n + nlogn）

2.双指针方法：由于是升序，元素会出现大于零或者小于0的情况，我们需要比较负数平方与正数平方的大小进行排序。

// solution 1 暴力解法 比较简单
class Solution{
public:
    vector<int> sortSquares(vector<int>& A){
		for(int i = 0;i < nums.size();i++){
			nums[i] *= nums[i];
            
        }
    	sort(nums.begin(),nums.end());// 直接排序
        return nums
    }
};

在前面我们使用了快慢指针来更新数组：例如移除元素那一题 leetcode 27

// 快慢指针
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        int k = 0;
        for (int i = 0; i < size; i++) {
            if (nums[i] != val) { // 发现需要移除的元素，就将数组集体向前移动一位
                nums[k++] = nums[i];    
                }
              
            }
        return k;
        }
    };

思考：

怎么实现呢？既然双指针，那么就定义一个数组起始指针i，尾部指针j。依然使用nums数组空间进行覆盖。

问题：

如何覆盖，从小到大覆盖还是从大到小覆盖？

1.假设用从小到大覆盖，要找到最小值，就要正数最小，负数最大中去取，操作比较麻烦。

2.假设用从大到小覆盖，要找到最大值只需从两端开始指针移动，数组也从后往前赋值。

// solution 2 双指针
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        int k = nums.size() - 1;
        for (int i = 0,j = nums.size() - 1; i < size; i++) {
            if (nums[j] * nums[j] >= nums[i] * nums[i]) { 
                nums[k--] = nums[j] * nums[j] ;
                j --;
                }
            else {
                nums[k--] = nums[i] * nums[i];
                i ++;
            }
                
            }
        return nums;
        }
    };

题目 ：209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：解释：子数组 [4,3] 是该条件下的长度最小的子数组。

提示：

• 1 <= target <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

思路：

1.这道题初看起来没什么思路，采用暴力解法把全部组合求解强算出来，但是会超时。

1	12	123	1234	12345	123456
2	23	234	2345	23456
3	34	345	3456
4	45	456
5	56
6

solution 1 暴力算法（会超时）
public:
    int minSubArrayLen(int target, vector<int>& nums) {
    int class Solution {
	l = nums.size();
        
        int res = INT_MAX;
        for(int i = 0;i < l;i ++){
            int sum = 0;  // 每过一个 i 就重置 sum
            // 注意这个条件：sum >= target 还是sum -nums[j] >= target
            for(int j = i;j < l;j ++){
                sum += nums[j];
                if(sum >= target){
                    res = min(res, j - i + 1);// 更新res值
                    
                }
                    
            }

        }
        if(res == INT_MAX) res = 0; //相加不等于target 的值
        return res;    
    }
};

2.双指针（滑动窗口）

与907有序数组的平方类似，所有数都是正数，所以每添加一个数和都是递增的，所以具有单调性。

刚开始看这个代码的时候以为与暴力解法是相同的，都是需要从前往后遍历，实际上快指针i先过一遍数组，找到满足条件的末端位置。

然后另外一个指针从零开始去除该元素，若可去除，则更新i 的位置，因为满足条件时，数组值是递减的。

solution 2 双指针
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int l = nums.size(),sum = 0;
        int res = INT_MAX;
        for(int i = 0,j = 0;i < l;i ++){
    		sum += num[i]；
            // 提前预判是否有可以减去
    		while(sum -nums[j] >= target){
        		res = min(res, i - j + 1); //更新满足数组长度 
        		sum -= num[j++];  //j ++ 更新指针 从前到后
        }
        if(res == INT_MAX) res = 0; //相加不等于target 的值
        return res;    
    }
};

题目：leetcode 59 螺旋矩阵

力扣题目链接(opens new window)

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思考：

1. 边界条件: 在循环中填充矩阵的每一行或每一列时，需要确保你不会超出矩阵的边界。
2. 更新边界: 每完成一次边界的填充，你需要更新这个边界。例如，当你完成了从左到右的顶部边界填充后，你需要将上边界下移一行。
3. 循环条件: 循环的条件是当前的填充数字小于等于 n * n。这是因为我们要填充的数字的范围是从1到 n * n。
4. 方向转换: 在填充完矩阵的一个边界后，需要更改填充方向。方向的顺序是：从左到右，从上到下，从右到左，从下到上。然后这个过程会一直重复，直到矩阵填满。
5. 填充顺序: 需要注意的是，每次填充的数字都是连续的，每填充一次，数字加1。
6. 矩阵大小为偶数和奇数的情况: 当矩阵的大小为偶数时，所有的元素都可以在四个方向上的填充过程中被填充。但是，如果矩阵的大小为奇数，那么最中心的元素是不会在四个方向上的填充过程中被填充的，需要单独处理。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n));
        int num = 1;
        int left = 0, right = n - 1, top = 0, bottom = n - 1;
        while (num <= n * n) {
            for (int i = left; i <= right; i++) res[top][i] = num++; // 从左到右
            top++; // 缩小上边界
            for (int i = top; i <= bottom; i++) res[i][right] = num++; // 从上到下
            right--; // 缩小右边界
            for (int i = right; i >= left; i--) res[bottom][i] = num++; // 从右到左
            bottom--; // 缩小下边界
            for (int i = bottom; i >= top; i--) res[i][left] = num++; // 从下到上
            left++; // 缩小左边界
        }
        return res;
    }
};