代码随想录随心记录贴01

二分查找

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

使用条件：

1.数组为有序数组 

2.数组中无重复元素 否则会返回多个下标

边界条件（定义区间）

边界条件的定义是程序员在写代码时非常容易犯错的点，在二分法中，有两种定义区间，分别为：

1.左闭右闭([left,right])

2.左闭右开([left,right))

对于以上两种区间，二分法有着两种不同的写法：
 

左闭右闭：

对于循环条件来说，由于左右都是闭集，因此当left==right是可以找到所求，满足区间定义，所以此时的边界条件为：while (left <= right) 。

另一方面，对于循环内的区间赋值，要写为：left/right = middle +/-1，举个例子，当middle位置的数值大于目标所求，即：nums[middle] > target，nums[middle]并不是要找的target值，此时区间右侧要变化，如果赋值为：right=middle，由于闭区间的特性，就会将已经确定不等于target的nums[middle]囊括进下一轮循环，因此我们直接取middle-1。nums[middle] <target时原理同上，不再过多赘述。

左闭右开：

对于循环条件来说，由于右边都是开集，因此当left==right并不满足区间定义，所以此时的边界条件为：while (left < right) 

另一方面，对于循环内的区间赋值，要写为：right / left = middle / middle+1，相同的例子，当middle位置的数值大于目标所求，nums[middle]并不是要找的target值，此时赋值为：right = middle，由于右侧开区间的特性，就会将已经确定不等于target的nums[middle]排在区间之外，因此我们直接取middle。nums[middle] <target时原理同上述左闭区间，不再过多赘述。

例题：

这里用leecode 34题作为例题：

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

我的解决思路是先用二分查找找到Target所在的位置，然后向前向后去找边界。

实现代码如下(C++)：

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

值得注意的是，在随想录中，为我们提供了一种防止求middle时因为数值过大导致溢出的写法，

即：middle = left + ((right - left) / 2) 

笔者建议将其记下来，在以后使用二分法解决问题时，将该语句用于求middle。

那么到这里，二分法的学习就结束了，接下来我们将进入数组中让人比较头痛的删除元素。

移除元素

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

要求空间复杂度为O(1)。

和链表不同，由于数组的连续性，删掉某一元素之后，后面的元素并不会自动向前对齐，因此需要删除元素后，再调整数组的元素位置，达到删除的效果。

双指针法：

大致思路如下：
首先创建两个指针指向该数组的第一个元素，一个称为快指针(Fast)，另一个则为慢指针(Slow)，快指针负责寻找新数组的元素，慢指针负责搜索新数组中的元素的位置，这么说可能有点难以理解，接下来我们通过代码来讲解：

int slow=0;
for(int fast=0;fast<nums.size();fast++){
if(val!=nums[slow])
nums[slow]=nums[fast];
slow++
}

fast向后遍历整个数组，在循环中，由slow指针来寻找和val数值相等的元素的位置，当nums[slow]与val相等时，说明该位置的元素需要被删除，即在该次循环中slow指向不变，给新数组中的元素腾出位置，fast继续向后去寻找下一个应该放在新数组的元素，可以理解为直接跳过该元素。

此时我们就可以得到一个时间复杂度只有O(1)，空间复杂度为O(n)的算法。

同样，为了巩固学习，我们来做一个例题：

例题：

给你一个非严格递增排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的相对顺序 应该保持一致 。然后返回 nums 中唯一元素的个数。

看到删除数组元素，自然的想到了可以尝试使用双指针解决，同样的，让fast指针去寻找新数组的元素，判断元素是否重复出现，然后将其放入slow指针的位置即可，本题容易写错的点在于对边界的处理，判断元素是否重复出现时，如果使用nums[fast]!=nums[fast+1]，那么在对于处理最后一个元素重复出现的情况时，例如[1,1]，会出现超出数组定义区间的问题，因此我们可以让fast和slow指针从第二个元素的位置开始和前一个元素进行对比，这样就不用担心出错了，此外，对于元素个数<=1的情况，我们直接返回数组大小即可。

具体代码如下：
 

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

    }
      return sum;
    }
};

后续会不定期更新我的学习过程。