代码随想录刷题 | Day2

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

今日学习目标

有序数组的平方（977）
长度最小的子数组（209）
螺旋矩阵II（59）

一、算法

1.有序数组的平方

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

个人思路：
对数组中每一个元素平方后，使用快速排序方法进行排序，时间复杂度位O(nlogn)。

双指针思路：
平方后的数组元素的大小趋势为由两边到中间递减，我们可以比较两边的元素，从后至前放入新数组中。时间复杂度O(n)。

双指针代码如下：

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


};

总结：
1.for循环中判断语句i<=j，如果不判定i=j，会出现漏掉一个元素的情况。
2.太久没复习，快速排序不熟。

2.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

个人思路：两层for循环遍历。

滑动窗口思路：
滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

如果移动的是起始位置，那么起始位置遍历，就和双循环没什么区别了。所以遍历终止位置，窗口值大于target，移动起始位置，保证窗口内满足>=target长度最小的连续数组。

滑动窗口代码如下：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //初始化变量，以确保在之后的计算或比较中，result 的初始值是一个不会被其他值覆盖的较大值。
        int result = INT32_MAX;
        //滑动窗口数值之和
        int sum = 0;
        //滑动窗口起始位置
        int i = 0;
        //滑动窗口的长度；
        int subLength = 0;
        for(int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            while(sum >= target) {
                //子序列的长度
                subLength = (j - i + 1);
                result = result < subLength ? result : subLength;
                sum -= nums[i++];
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

总结：
1.需要确定如下三点：窗口内是什么？如何移动窗口的起始位置？如何移动窗口的结束位置？
2.滑动窗口的写法，以及虽然使用了while循环，但是每个元素是被操作两次，时间复杂度是 2n，即O(n)。

3.螺旋矩阵II

题目：给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
思路：矩阵有四条边，每条边的区间判断都要一致，这样才会按照一定的规则填充进去，可以选择左开右闭或者左闭右开.

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;
        int startY = 0;
        //记录指向的位置
        int i, j;
        //控制每条边的长度，左闭右开
        int offset = 1;
        //矩阵内每个元素的值
        int count = 1;
        while(loop--) {
            //左上→右上
            for(j = startY; j < n - offset; j++) {
                result[startX][j] = count++;
            }
            //右上→右下
            for(i = startX; i < n - offset; i++) {
                result[i][j] = count++;
            }
            //右下→左下
            for(; j > startX; j--) {
                result[i][j] = count++;
            }
            //左下→左上
            for(; i > startY; i--) {
                result[i][startY] = count++;
            } 
            startX++;
            startY++;
            offset++;
        }
        // 如果n为奇数的话，赋值给矩阵最中间的位置
        if (n % 2) {
            result[n/2][n/2] = count;
        }
        return result;
    }
};

二、快速排序

快速排序算法的关键在于划分操作，假设每次总以当前数组中第一个元素为基准对数组进行划分，数组中比基准值大的向右移动，小的则向左移动，循环遍历即可划分完成。

void QuickSort(ElemType A[], int low, int high) {
	if (low < high) {
		//划分操作
		int pivotpos = Partition(A, low, high)
		//递归
		QuickSort(A, low, pivotpos - 1);
		QuickSort(A, pivotpos + 1, high);
	}
}

int Partition(ElemType A[], int low, int high) {
	ElemType pivot = A[low];
	while (low < high) {
		while (low < high && A[high] >= pivot) --high;
		A[low] = A[high];
		while (low < high && A[low] <= pivot) ++low;
		A[high] = A[low];
	}
	A[low] = pivot;
	return low;
}

---

今日心得

用时：本次未记录
快速排序有些遗忘，参照王道数据结构进行了复习。个人认为长度最小的子数组和螺旋数组中重要的点在于边界的判断。

学习及参考内容

代码随想录
王道数据结构