代码随想录刷题随记1-二分查找，删除数组元素

代码随想录刷题随记1-二分查找，删除数组元素

上午一道下午一道加上写博客耗时接近2h

LeetCode 704-二分查找

题目链接
第一题比较简单
我的习惯是默认target 是在一个在左闭右闭的区间里。
用的是递归解决二分问题。
解题代码：

class Solution {
public:
    int subsearch(vector<int> & nums,int left,int right,int target){
        if(left==right){
            return nums[left]==target? left:-1;
        }
        //if(left>right){
         // return -1;
        //} 这个地方一开始写了，后来一琢磨貌似left不可能大于right删了也没问题
        int mid=left+((right-left)>>1);
        if(nums[mid]==target){
            return mid;
        }
        if(nums[mid]>target){
            return subsearch(nums,left,mid,target);
        }
        else{
            return subsearch(nums,mid+1,right,target);
        }
    }
    int search(vector<int>& nums, int target) {
       if(nums.size()==0){
         return -1;
       }
       return subsearch(nums,0,nums.size()-1,target);
    }
};

其中遇到的一点小bug是忘记写left=right时没找到的情况。

• 二分的本质： 根据是否满足题目的条件来缩小答案所在的区间。
• 二分的使用前提：有序数组
• 二分的时间复杂度是O(logn)

看看题解以后觉得递归写着很简单但是还是有必要优化一下写成非递归版本：
参考卡哥题解

class Solution {
public:
    int search(vector<int>& nums, int target) {
       if(nums.size()==0){
         return -1;
       }
       int left=0;
       int right=nums.size()-1;
       //这里注意等号
       while(left<=right){
        if(left==right){
            return nums[left]==target? left:-1;
        }
        int mid=left+((right-left)>>1);
        if(nums[mid]==target){
            return mid;
        }
        if(nums[mid]>target){
            right=mid;
        }
        else{
            left=mid+1;
        }
       }
       return -1;
    }
};

27. 移除元素

leetcode链接
注意的一点是，由于是数组不是链表，所以删除只能用后面的数值去覆盖要删除的值

暴力解法

一个时间复杂度是$O(n^2)$ 的解法是，每次遍历到要删除的位置就把后面的所有的往前移动一次
解题代码：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size=nums.size();
        //发现如果把size改成nums.size() leetcode就会报超时。。。
        for(int i=0;i<size;i++){
            if(nums[i]==val){
                for(int j=i;j<size-1;j++){
                    nums[j]=nums[j+1];
                }
                size--;
                i=i-1;
            }
        }
        return size;
    }
};

双指针方法

通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
这里一个指针从左往右边遍历，另一个指针从右边往左边遍历，指针不回退，所以一共遍历了一次数组就完成了覆盖过程，时间复杂度$O(N)$
解题代码：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
      int leftptr=0;
      int rightptr=nums.size()-1;
      while(leftptr<=rightptr){
          while(leftptr<=rightptr&&nums[leftptr]!=val){
            leftptr++;
          }
          while(rightptr>=leftptr&&nums[rightptr]==val){
            rightptr--;
          }
          if(rightptr>leftptr)
            nums[leftptr++]=nums[rightptr--];
      }
      return leftptr;
    }
};

这里要注意 while(leftptr<=rightptr&&nums[leftptr]!=val)这里的条件不能写成 while(nums[leftptr]!=val&&leftptr<=rightptr)要先判断合法性不然会出现错误