代码随想录算法训练营第一天

LeetCode 704.二分查找

二分查找的两种书写形式，一种左闭右开，一种左闭右闭

. - 力扣（LeetCode）

关于循环条件判断问题

这里我们对于left（下面left用l代替，right用r代替）向上调整所用的条件是l=mid+1

对左闭右开，while的判断条件必须为while（l < r)，因为r=num.size()，在排列升序数组过程中，l可能出现在最后一位，即下标为num.size()-1；此时l=mid+1=r；会出现溢出的下现象

对左闭右闭，while的条件为while（l < r），此时最极端的情况也就是l=r=num.size()；不会出现溢出现象

左闭右开

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

左闭右开中对于r的调整条件出现的问题

因为我们的原理是右闭条件，当nums[mid]>target时，中间值：nums[mid]是不包含在我们需要查找的区间内，r=mid就是把mid作为了新需要查找的左区间的在区间外的r

若换做r=mid-1；力扣无法通过，因为此时我们又把新的r算在了可能出现目标值的区间内，

此时我们原理上（l==r）时判定可能出现值，与我们设定的左闭右开区间不符合，所以可能出现l==r 和 l > r 情况，需要在while循环外再进行判断

这样的代码又与之前的思想违背，有点不伦不类。

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

在力扣上又通过不了，因为会出现l=0，r=-1的情况，这时候又溢出区间。

综上，r的转换条件只能用r=mid；

到这里我才理解了卡哥说的left==right在区间[left,right)没意义是什么意思（下面是卡哥的博客摘录，关于while条件在左闭右开中的选择）：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

左闭右闭

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

将左闭右开弄清楚了左闭右闭就简单许多

LeetCode 27.移除元素

暴力解法

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

暴力比较简单，时间复杂度较大，注意每次覆盖后i也需要-1即可

双指针解法

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

快指针：用于遍历数组中的所有元素

慢指针：用于生成新的数组

过程及遍历顺序：

先fast扫描，若不为val，则将fast位置的值赋给slow

若为val，则slow不动，fast++，扫描下一个位置

一次循环结束（结束只fastpoint++）执行完毕，此时fast-slow=删除的元素个数

这里要注意顺序：slowpoint的移动与否的执行总是在fastpoint之前，所以slow移动后的值其实是新数组大小+1。

如nums = [0,1,2,2,3,0,4,2], val = 2

删除第一个元素2：经过1后，此时两个指针都应该指向2，这时候才判断是否val==nums[fastpoint]

然后slowpoint不动，fastpoint向前移动

总结

感觉收获还是挺大的，至少我彻底搞懂了二分和双指针，自己分析了二分的一些情况，重点是理清了整个算法思想，这也提醒我以后要沿着算法思想写题目，不要随便更改。花的时间确实多了点，以后再接再厉，争取用更少时间做出更好的效果