2024年10月8日
参考github网站:代码随想录

1.二分查找

leetcode
视频

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while(left<=right){
            int middle = (left+right)/2;
            if(nums[middle] > target){
                right = middle -1;
            }
            else if(nums[middle] < target){
                left = middle +1;
            }
            else return middle;
        }
        return -1;
    }
};

核心是边界处理

以左右均为闭区间为例:

第一个点是while循环中left是可以等于right的,因为[1,1]仍然有意义,否则就是丢情况;

第二个点是在进行左右两个区间分割的时候,是将middle-1传递给right或middle+1传递给left,如果将middle传递,是因为区间是闭区间,middle是被包含的,但是middle一定不是target的目标值(nums[middle] > target)。相反在左闭右开区间,开区间的部分就是传递middle了。

2.移除数组元素(快慢指针)

leetcode
视频
在牛客上遇见过,当时用的暴力求解:

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

思路上就是外层循环遍历每个元素,找到目标元素后内层循环依次向前替换位置。
但是这里有个问题:for (int j = i + 1;…),如果是j=i,那么后面nums存在j+1造成数组超限。

快慢指针的方法:
两个指针一个fast,一个slow,分别有自己的职责。
快指针查找目标值(找寻新数组元素),慢指针查找指向更新的位置。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        int slow = 0;
        for(int fast = 0; fast < size; fast++){
            if(val != nums[fast]){
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
};

快指针在for循环中不停下,一直走到头;慢指针当快指针找到目标元素的时候停下不动,确定好交换的初始位置(尤其是遇到连续两个目标元素的时候!!)。

3.有序数组的平方

视频
leetcode
暴力求解,先平方,后sort排序函数。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(auto it = nums.begin(); it!=nums.end(); it++){
            *it *= *it;
        }
        
        sort(nums.begin(), nums.end());
        
        return nums;
    }
};

由于数组的特殊性,两头绝对值大,中间是个“波谷”,所以采用双指针从两侧向中间靠拢。

思路:双指针

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        for (int i = 0, j = k; 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;
    }
};

4.长度最小的子数组

视频
力扣

暴力求解的思路是:两个for循环,从头开始。假设外层层for看作一个指针,内层for看作一个指针,内层的指针需要遍历完整个数组。

采用滑动窗口的方法:子数组的尾部指针先动,先定好尾部的位置,这样头部向尾部靠拢即可。尾部指针遍历完整个数组,依次查找满足要求的子序列。

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

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部