代码随想录算法训练营Day2 | 数组part02

原创已于 2023-12-29 15:17:39 修改 · 566 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #leetcode

于 2023-12-29 00:39:03 首次发布

本文介绍了如何在LeetCode上解决三个编程问题：有序数组的平方计算、长度最小的子数组和螺旋矩阵II。分别提供了两种解决方案，涉及遍历策略和时间/空间复杂度分析。

977. 有序数组的平方

leetcode链接
 代码随想录链接
一刷状态：解出

思路

从两边遍历到中间

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result;
        if(nums.empty())
        {
            return result;
        }

         // 从左右向中间遍历
         int front = 0;
         int back = nums.size()-1;
         while(front!=back)
         {
             int num_front = nums[front]*nums[front];
             int num_back = nums[back]*nums[back];
             if(num_front>num_back)
             {
                 result.push_back(num_front);
                 front++;
             }
             else
             {
                 result.push_back(num_back);
                 back--;
             }
         }
         result.push_back(nums[front]*nums[front]);

         reverse(result.begin(), result.end());
         
         return result;

    }
};

看完题解后的知识点补充

修改存储结构数组的逻辑，从后方加入，就可以减少反转数组这一步骤。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(), 0);
        if(nums.empty())
        {
            return result;
        }

        int size = nums.size()-1;

         // 从左右向中间遍历
         int front = 0;
         int back = nums.size()-1;
         while(front!=back)
         {
             int num_front = nums[front]*nums[front];
             int num_back = nums[back]*nums[back];
             if(num_front>num_back)
             {
                 result[size--] = num_front;
                 front++;
             }
             else
             {
                 result[size--] = num_back;
                 back--;
             }
         }
         result[size--] = nums[front]*nums[front];
         
         return result;

    }
};

209. 长度最小的子数组

leetcode链接
 代码随想录链接
一刷状态：未解出

思路

1. 暴力解法

时间复杂度：O(n^2)
空间复杂度：O(1)

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {

        int result = INT_MAX;
        int length = 0;

        for(int i = 0; i<nums.size(); i++)
        {
            int sum = 0;
            for(int j = i; j<nums.size(); j++)
            {
                sum += nums[j];
                if(sum>=target)
                {
                    length = j - i + 1;
                    result = length<result?length:result;
                    break;
                }
            }
        }
        if(result==INT_MAX) return 0;
        else return result;

    }
};

2. 滑动窗口

时间复杂度：O(n)
空间复杂度：O(1)

思路理解：重点在于理解滑动窗口，窗口的右括号从0遍历到尾，左括号根据sum的值来调整，超过了target，则尝试滑动一位来观察是否可以缩小窗口，达到题目寻找最小子数组的目的。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int j = 0;
        int sum = 0;
        int length = 0;
        int result = INT_MAX;

        for(int i=0; i<nums.size(); i++)
        {
            sum += nums[i];
            while(sum>=target)
            {
                length = i - j + 1;
                if(length<result) result = length;
                sum -= nums[j];
                j++;
            }
        }
        
        if(result==INT_MAX) return 0;
        else return result;
    }
};

59. 螺旋矩阵 II

leetcode链接
 代码随想录链接
一刷状态：差一点，条件的符号没有写对

思路

规定四个方向的边界，写四个边的遍历，注意规定好边界条件，索引的改变会影响到后续索引的使用，所以在后两个循环需要添加条件判断。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int left = 0;
        int right = n-1;
        int top = 0;
        int bottom = n-1;

        vector<vector<int>> result(n, vector<int>(n, 0));
        int k = 1;

        while(bottom>=top&&right>=left)
        {
            for(int i = left; i<=right; i++)
            {
                result[top][i] = k;
                k++;
            }
            top++;

            for(int i = top; i<=bottom; i++)
            {
                result[i][right] = k;
                k++;
            }
            right--;

            if(bottom>=top)
            {
                for(int i = right; i>=left; i--)
                {
                    result[bottom][i] = k;
                    k++;
                }
                bottom--;
            }
            

            if(right>=left)
            {        
                for(int i = bottom; i>=top; i--)
                {
                    result[i][left] = k;
                    k++;
                }
                left++;
            }
            
        }
        return result;

    }
};