代码随想录刷题笔记（一）

代码随想录刷题笔记（一）

数组部分刷题笔记

数组

二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

核心：使用while循环 每次只更新一个边界（左边界/右边界）

注意边界左闭右开 [ )

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组

核心：双指针法，for循环使用快指针去寻找目标元素，未发现目标元素则快慢指针一起移动+1，当发现元素后，只动快指针

// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

有序数组的平方

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

暴力解法：for循环逐个平方，再排序

示例 1：

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

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
		vector<int> res(A.size(),0); //初始化，长度为A.size()，值为0
        int k = A.size()-1;//k控制res的下标
        for(int i = 0, j = k; i<=j;){
            if(A[i]*A[i] < A[j]*A[j]){
                res[k--] = A[j]*A[j];//执行完赋值 然后k--
                j--;
            }
            else{				//A[i]*A[i] >= A[j]*A[j]
                res[k--] = A[i]*A[i];//执行完赋值 然后k--
                i++;
            }
        }
        return result;
    }
};

长度最小的子数组

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

示例：

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

两层for循环容易超时

滑动窗口

核心：使用for循环控制窗口的尾部，当满足条件时候，while循环收缩窗口头部，并更新最小窗口大小

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
		int res = INT32_MAX;//最小窗口长度
        int subLen = 0;//当前满足条件的窗口长度
        int i = 0;//窗口头部
        int sum = 0;//窗口内数值之和
        for(int j = 0; j < nums.size(); j++){
            sum += nums[j];//逐个加
            while(sum >= s){//满足条件
                subLen = j-i+1;//计算当前窗口长度
                res = subLen < res? subLen:res;//当前窗口是否小于已记录的最小窗口长度
                sum -= nums[i];//收缩头部，看是否还满足条件
            }
        }
        //如果是res没改变，则未找到满足条件的最小数组，返回0
        return res == INT32_MAX ? 0 : res;
};

螺旋矩阵2

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

示例:

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

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i,j;
        while (loop --) {
			i = startx;//startx 和starty只是控制每轮循环的起点
            j = starty;

            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
           for(j = starty; j < n - offset; j++){
               //res[startx][j] = count++;
               res[i][j] = count++;
           }
            // 模拟填充右列从上到下(左闭右开)
            for(i = startx; i < n-offset;i++){
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for(; j>starty; j--){
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for(; i>startx; i--){
                //res[i][starty] = count++;
                res[i][j] = count++;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
      		startx++;
            starty++;

            // offset++ 控制每一圈里每一条边遍历的长度
            offset++;
        }

        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};

上述资料为个人学习总结笔记，学习资源来自《代码随想录》