专题1 —— 数组

1 704.二分查找

704.二分查找
视频讲解

1.1 方法1

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

1.2 方法2

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;
    }
};

1.3 方法3(Acwing二分查找)

参考这里的二分查找做法

• 注意边界条件

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        while(l < r)
        {
            int mid = l + r >> 1;// 这里mid = l + r >> 1则必须使用nums[mid] >= target进行判断
            if(nums[mid] >= target) r = mid;// 符合第一种情况(acwing二分查找题)
            else l = mid + 1;
        }
        if(nums[r] != target) return -1;
        return r;
    }
};

2 27.移除元素

27.移除元素
视频讲解

2.1 暴力算法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        for(int i = 0; i < size; i++)
        {
            if(nums[i] == val)// 发现需要移除的元素就将元素整体向前移动一位
            {
                for(int j = i + 1; j < size; j++)
                {
                    nums[j - 1] = nums[j];
                }
                i--;// 因为i所指的元素都向前移动一位了，所以i也要向前移动一位
                size--;// 数组长度-1
            }
        }
        return size;
    }
};

2.2 双指针法(acwing做法)

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int k = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            if(nums[i] != val)// 遇到不相同的元素，就将其加入到nums[k++]
            nums[k++] = nums[i];
        }
        return k;
    }
};

3 209.长度最小的子数组

209.长度最小的子数组
视频讲解

3.1 双指针法(acwing方法)

INT_MAX解释

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int res = INT_MAX;
        int sum = 0;
        for(int i = 0, j = 0; i < nums.size(); i++)
        {
            sum += nums[i];
            while(sum - nums[j] >= target) sum -= nums[j++];// 减去当前的nums[j]
            if(sum >= target) res = min(res, i - j + 1);// 这里必须是>=
        }
        if(res == INT_MAX) res = 0;// 无解
        return res;
    }
};

4 59.螺旋矩阵II

59.螺旋矩阵II
视频讲解
vector的初始化解释

4.1 acwing方法

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        // 初始化一个n行、n列，初始元素为0的二维数组
        vector<vector<int>> res(n, vector<int>(n,0));
        // 右->下->左->上的顺序，而且x坐标是垂直向下，y坐标是水平向右
        int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
        // 当i = 1时，对应(x,y)是(0,0)，d表示选择哪种模式，d=0，表示向右，d=1表示向下
        for(int i = 1, x = 0, y = 0, d = 0; i <= n*n; i++){
            res[x][y] = i;// 坐标[x][y]
            int a = x + dx[d], b = y + dy[d];// a表示x坐标，b表示y坐标，最大值是n-1(从0开始)
            if(a < 0 || a >= n || b < 0 || b >= n || res[a][b])// 最后res[a][b]表示这个格子已经填了数
            {
                d = (d + 1) % 4;// 更改方向
                a = x + dx[d], b = y + dy[d];// 继续往下走
            }
            x = a, y = b;// 更新a和b
        }
        return res;
    }
};