代码随想录算法训练营02 | 977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵

5. 有序数组的平方（977）

C++：

暴力求解：

首先对数组进行平方，得到新的数组，然后对数组使用冒泡排序，问题得以解决

需要说明的是，冒泡排序中间，在第二层循环中，j 的初始值要从 0 开始，不能是自己寻思的 i+1 。因为，第一层循环是确定到底要进行多少次这样的排序，第二层才是实际进行排序的，从第一个数开始，与相邻的第二个数开始比较大小，是否交换位置……注意：在每完成一轮排序后，实际找到自己位置的是最后一个数！

vector<int>& bulleSort(vector<int>& nums, int len){
    for (int i = 0; i < len - 1; i++){
        for (int j = 0; j < len - i - 1; j++){
            if (nums[j] > nums[j + 1]){
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
    return nums;
}

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        A = bullerSort(A, A.sort()) // 冒泡排序
        return A;
    }
};

// ---------------------------------------------
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

有一点比较好奇，这个快速排序的方法到底是什么，为啥在leetcode上运行的速度比冒泡排序快呢？之后学到了再来补吧

快慢指针：

这里一个很巧妙的方法是，先比较两头数据平方后的大小！

然后选择大的放在新的数组里，稍微难的是，在下标变化的时候，仔细判断到底是怎么个变化法

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int length = nums.size(), k = length - 1;
        vector<int> result(length, 0);
        for (int i = 0, j = length - 1; i <= j;){
            if (nums[i] * nums[i] <= nums[j] * nums[j]){
                result[k--] = nums[j] * nums[j];
                j--;
            }else{
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

6. 长度最小的子数组（209）

C++:

暴力求解：

主要学习了result的设置，结合最后的输出，感觉很巧妙。

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

滑动窗口：

主要是得注意审题，题目中说的是，长度最小的，连续的，子数组！不是从这里面挑出最少的数之和大于target

那么滑动窗口的想法就很不错，先是终止下标往右滑动，寻找sum大于等于target的数组，如果符合了，再让起始下标开始往右移动，寻找最短的子数组。

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

还有一点值的学习，据时result的这个设置，先给其赋予一个最大值，然后在所有可能的长度选择中，逐一的挑选出一个最短的值来接替

7. 螺旋矩阵（59）

C++：

坚持循环不变量原则！就是控制处理区间的状态，如果是左闭右开，那就都是这样，不要来回变，导致循环的条件来回变化，写的错误太多。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {

        int start_x = 0, start_y = 0;
        int offset = 1, count = 1;
        int i,j;
        vector<vector<int>> matrix(n, vector<int>(n, 0));

        while (offset <= n/2){

            i = start_x;
            j = start_y;

            for (j = start_y; j < n - offset; j++){
                matrix[start_x][j] = count++;
            }
            for (i = start_x; i < n - offset; i++){
                matrix[i][j] = count++;
            }
            for (; j > start_y; j--){
                matrix[i][j] = count++;
            }
            for (; i > start_x; i--){
                matrix[i][j] = count++;
            }

            start_x++;
            start_y++;
            offset++;
        }

        if (n % 2 == 1){
            matrix[start_x][start_y] = count;
        }

        return matrix;
    }
};

自己在写的时候，遇到了几个问题：

1. 首先是不太熟悉 vector 容器，等后续学学了回来把学习笔记补上（这导致我在定义二维数组的时候出现了问题）
2. 全局变量和局部变量的问题，在第一次编译的时候，并没有在将 i,j 定义为全局变量，导致在循环的时候，说没有这个变量

Python:

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        matrix = [[0 for _ in range(n)] for _ in range(n)]
        start = 0
        offset, count = 1, 1

        for offset in range(1, n/2+1):

            for i in range(start, n - offset):
                matrix[start][i] = count
                count += 1
            for i in range(start, n - offset):
                matrix[i][n - offset] = count
                count += 1
            for i in range(n - offset, start, -1):
                matrix[n - offset][i] = count
                count += 1
            for i in range(n - offset, start, -1):
                matrix[i][start] = count
                count += 1
            
            start += 1
            offset += 1

        if n % 2 != 0:
            matrix[offset - 1][offset - 1] = count
        
        return matrix

需要注意的就一点：

1. 要多加练习，要不然转眼就忘了编写的语法是什么了