day01 二分查找 移除元素

发布时间:2023年12月28日

题目1:704二分查找

题目链接:704 二分查找

题意

找到升序的整数数组nums中与target相等的数字,并返回下标,如果没有则返回-1

二分法前提:有序数组,无重复元素

区间左闭右闭? ?[left,right]

意味着可以取到right,即可以取到区间最右侧的值

定义right元素的时候,注意right=nums.size()-1? 可以取到

代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //左闭右闭
       int left = 0;
       int right = nums.size()-1;
       while(left<=right){
        //    int mid = (left+right)/2;
        // int mid = left + ((right - left)/2);
        int mid = left + ((right - left)>>1);
           if(nums[mid]<target){
               left = mid + 1;
           }
           else if(nums[mid]>target){
               right = mid - 1;
           }
           else {
               return mid;
           }
       }
       return -1;
    }
};
  • 时间复杂度:O(log n)
  • 空间复杂度:O(1)

区间左闭右开? [left,right]

意味着不可以取到right,即不可以取到区间最右侧的值

定义right的时候,注意right=num.size()? ?取不到

代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //左闭右开
        int left = 0;
        int right = nums.size();
        while(left<right){
            // int mid = (left + right) / 2;
            // int mid = left + ((right - left)/2);
            int mid = left + ((right - left) >> 1);
            if(nums[mid]<target){
                left = mid + 1;
            }
            else if(nums[mid]>target){
                right = mid;
            }
            else {
                return mid;}
        }
        return -1;
    }
};
  • 时间复杂度:O(log n)
  • 空间复杂度:O(1)

扩展题目a:35搜索插入位置

题目链接:35 搜索插入位置
题意

nums数组升序排列(无重复元素),返回数组中与target相等的元素的位置,若没有,则返回target在数组中应该插入的位置

插入的位置会有如下4种情况:

  • 目标值在数组所有元素之前? ?
  • 目标值等于数组中某一个元素? return mid
  • 目标值插入数组中的位置? ??
  • 目标值在数组所有元素之后??
左闭右闭

代码

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        //左闭右闭
        int left = 0;
        int right = nums.size() - 1;
        while(left <= right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] < target){
                left = mid + 1;
            }
            else if(nums[mid] > target){
                right = mid - 1;
            }
            else {
                return mid;
            }
        }
        // return left;
        return right + 1 ;
        //不可以返回mid,mid是一个局部变量,只在while循环里面有用
    }
};

注意最终return的不可以是mid,因为mid是一个局部变量,只在while循环里面有效

  • 时间复杂度:O(log n)
  • 空间复杂度:O(1)
左闭右开

代码

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        //左闭右开
        int left = 0;
        int right = nums.size();
        while(left < right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] < target){
                left = mid + 1;
            }
            else if(nums[mid] > target){
                right = mid;
            }
            else {
                return mid;
            }
        }
        // return left;
        return right;  //与左闭右闭不同的是,左闭右开取不到右边界值,所以数字会插入在这个位置的
    }
};
  • 时间复杂度:O(log n)
  • 空间复杂度:O(1)
暴力解法(较高的时间复杂度)

循环遍历整个数组,比较数组的每个元素与target的大小关系

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
      //暴力解法
      for(int i = 0;i<nums.size();i++){
          if(nums[i] >= target){
              return i;
          } 
      }
      return nums.size();
    }
};
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

扩展题目b:在排序中查找元素的第一个位置

题目链接:34 在排序数组中查找元素的第一个和最后一个位置
题意

找出非递减排列的整数数组nums中? 与target相等的元素的开始位置和结束位置

如果不存在与target相等的元素,返回[-1,-1]

寻找target在数组里的左右边界,有如下三种情况:

  • 情况一:target 在数组范围的右边或者左边,例如数组{3, 4, 5},target为2或者数组{3, 4, 5},target为6,此时应该返回{-1, -1}
  • 情况二:target 在数组范围中,且数组中不存在target,例如数组{3,6,7},target为5,此时应该返回{-1, -1}
  • 情况三:target 在数组范围中,且数组中存在target,例如数组{3,6,7},target为6,此时应该返回{1, 1}

代码

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int rightboard = getrightboard(nums, target);
        int leftboard = getleftboard(nums, target);
        if(rightboard == -2 || leftboard == -2){
            return {-1,-1};
        }
        if(rightboard - leftboard > 1){
            return {leftboard + 1, rightboard - 1};
        }
        return {-1, -1};

    }
private:
    int getrightboard(vector<int>& nums, int target){
        int left = 0;
        int right = nums.size() - 1;
        int rightboard = -2;
        while(left <= right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid]>target){
                right = mid - 1;
            }
            else{
                left = mid + 1;
                rightboard = left;
            }
        }
        return rightboard;
    }

    int getleftboard(vector<int>& nums, int target){
        int left = 0;
        int right = nums.size() - 1;
        int leftboard = -2;
        while(left <= right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] >= target){
                right = mid - 1;
                leftboard = right;
            }
            else{
                left = mid + 1;
            }
        }
        return leftboard;
    }
};

题目2:27移除元素

题目链接:27 移除元素

题意

原地移除数组中所有数值等于val的元素,返回新的数组长度

暴力解法(两层for循环)

一层是循环遍历数组的每个元素,另一层是比较更新数组

代码

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--;//在nums[i]==val的情况下,元素都向前移了一位
               size--;//因为元素向前移动一位,所以长度减1
           }
       }
       return size;
    }
};
  • 时间复杂度:O(n^2)
  • 空间复杂度:O(1)

双指针★

fast快指针 nums[fast]与val比较? ?寻找新数组里面的元素(!=val)

slow新数组的下标

代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for(int fast = 0;fast < nums.size();fast++){
            if(nums[fast] != val){
                nums[slow] = nums[fast];
                slow ++;
            }
        }
        return slow;
    }
};
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)
文章来源:https://blog.csdn.net/qq_43773652/article/details/135255440
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。