代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素。

semirc9

已于 2024-06-24 17:15:52 修改

阅读量700

点赞数 16

分类专栏：代码随想录算法训练营文章标签：算法 c语言

于 2024-06-22 20:23:11 首次发布

本文链接：https://blog.csdn.net/semirc9/article/details/139887578

版权

代码随想录算法训练营专栏收录该内容

10 篇文章 1 订阅

订阅专栏

704.二分查找

题目链接：704. 二分查找 - 力扣（LeetCode）

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

二分查找适合有序、元素不重复、有边界范围的问题，可以用来求最值、查找满足一定条件的边界值等

思路就是把最后的结果锁定在一个 left，righ 区间内，难点在于区间边界的处理

二分查找的循环中，坚持循环不变量的原则，循环不变量就是我们的左右区间到底是左闭右开还是左闭右闭

左闭右开 [left,right)

int search(int* nums, int numsSize, int target) {
    int left=0;
    int right=numsSize; //因为右边是开区间取不到，所以初始化为numSize
    while(left<right){ //右边是开区间取不到,循环结束条件是<
        int mid=left+((right-left)>>1); //位运算比除法运算速度更快，不直接相加可以避免溢出
        if(nums[mid]>target){
            right=mid; //因为右边是开区间取不到,不需要mid-1
        }else if(nums[mid]<target){
            left=mid+1;
        }else{
            return mid;
        }
    }
    return -1;
}

左闭右闭 [left,right]

int search(int* nums, int numsSize, int target) {
    int left=0;
    int right=numsSize-1;//右边可以取到
    while(left<=right){ //右边可以取到，等号是有意义的
        int mid=left+((right-left)>>1);
        if(nums[mid]>target){
            right=mid-1;//右边可以取到，需要-1
        }else if(nums[mid]<target){
            left=mid+1;
        }else{
            return mid;
        }
    }
    return -1;
}

24.移除元素

题目链接：https://leetcode.cn/problems/remove-element/

题目描述：给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中
与 val不同的元素的数量

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定nums=[3,2,2,3], val = 3, 函数返回新的长度 2, 并且nums中的前两个元素均为2。不需要考虑数组中超出新长度后面的元素。

示例 2: 给定nums=[0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且nums中的前五个元素为 0, 1, 3, 0, 4。

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖

暴力求解 O(n^2)

两层for循环，一个for循环遍历数组元素，第二个for循环更新数组

int removeElement(int* nums, int numsSize, int val) {
    for(int i=0;i<numsSize;i++){
        if(nums[i]==val){
            for(int j=i;j<numsSize-1;j++){
               nums[j]=nums[j+1]; 
            }
            numsSize--;
            i--; //注意i要减1回到当前下标，否则是下一个元素
        }
    }
    return numsSize;
}

双指针 O(n)

通过一个快指针和慢指针在一个for循环下完成两个for循环的工作

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组

慢指针：指向更新新数组下标的位置

int removeElement(int* nums, int numsSize, int val) { 
    int i=0,j=0;
    for(;i<numsSize;i++){
        if(nums[i]!=val){
            nums[j++]=nums[i];
        }
    }
    return j;
}

35.搜索插入位置

题目链接：35. 搜索插入位置 - 力扣（LeetCode）

题目描述：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。假设数组中无重复元素。

思路

根据题意，有以下几种情况：

目标值在所有元素之前
目标值等于数组中某个元素
目标值插入数组中某个位置
目标值在所有元素之后

前三种可以归结为在数组中找到大于等于目标值的第一个元素的位置

暴力求解

int searchInsert(int* nums, int numsSize, int target){
    for(int i=0;i<numsSize;i++){
      if(nums[i]>=target){ //找到大于或者等于target的num[i]，i就是结果
      	return i;
      }
    }
    return numsSize; //target是最大的，或者 nums为空，则返回nums的长度
}

二分查找

因为数组是有限、有序且无重复元素，可以用二分查找

左闭右开

int searchInsert(int* nums, int numsSize, int target) {
    int left=0,right=numsSize;//定义左闭右开区间
    while(left<right){// 因为left == right的时候，[left, right)区间无效
        int mid=left+(right-left)/2;
        if(nums[mid]==target) return mid;
        else if(nums[mid]>target){
            right=mid; //target 在左区间，在[left, mid)中
        }else{
            left=mid+1; //target 在右区间，在 [mid+1, right)中
        }
    }
    // 分别处理如下四种情况
    // 目标值在数组所有元素之前 [0,0)
    // 目标值等于数组中某一个元素 return mid
    // 目标值插入数组中的位置 [left, right) ，return right 即可
    // 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
    return right;
}

左闭右闭

int searchInsert(int* nums, int numsSize, int target) {
    int left=0,right=numsSize-1;//定义左闭右闭区间
    while(left<=right){// left == right的时候，[left, right]区间有效
        int mid=left+(right-left)/2;
        if(nums[mid]==target) return mid;
        else if(nums[mid]>target){
            right=mid-1; //target 在左区间，在[left, mid-1]中
        }else{
            left=mid+1; //target 在右区间，在 [mid+1, right]中
        }
    }
    // 分别处理如下四种情况
    // 目标值在数组所有元素之前 [0,-1]
    // 目标值等于数组中某一个元素 return mid
    // 目标值插入数组中的位置 [left, right] ，return right+1 即可
    // 目标值在数组所有元素之后的情况 [left, right]，因为是右闭区间，所以 return right+1
    return right;
}

34. 在排序数组中查找元素的第一个和最后一个位置

题目链接：34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

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

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

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

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

暴力求解

思路：两个for循环，分别寻找第一个和最后一个目标值的位置

int* searchRange(int* nums, int numsSize, int target, int* returnSize) {
   int *ans=(int*)malloc(sizeof(int)*2);
    ans[0]=-1,
    ans[1]=-1;
   *returnSize=2;
    for(int i=0;i<numsSize;i++){
        if(nums[i]==target){
            ans[0]=i;
            break;
        }
    }
    for(int j=numsSize-1;j>=0;j--){
        if(nums[j]==target){
            ans[1]=j;
            break;
        }
    }
   return ans;
}

二分查找

思路：若数组中有目标值，找到左边第一个小于目标值的元素和右边第一个大于目标值的元素。没有则返回[-1,-1]。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int GetLeftBorder(int* nums, int numsSize, int target){
    int left=0;
    int right=numsSize;
    int leftBorder=-1;//leftBorder未被赋值时的值
    while(left<right){
        int mid=left+((right-left)>>1);
        if(nums[mid]==target){//寻找左边界，nums[middle] == target的时候更新right
            right=mid;
            leftBorder=mid;
        }else if(nums[mid]<target){
            left=mid+1;
        }else{
            right=mid;
        }
    }
    return leftBorder;
}
int GetRightBorder(int* nums, int numsSize, int target){
    int left=0;
    int right=numsSize-1;
    int rightBorder= -1;
    while(left<=right){
        int mid=left+((right-left)>>1);
        if(nums[mid]==target){//寻找右边界，nums[middle] == target的时候更新left
            rightBorder=mid;
            left=mid+1; 
        }else if(nums[mid]<target){ 
            left=mid+1;
        }else{
            right=mid-1;
        }
    }
    return rightBorder;
}
int* searchRange(int* nums, int numsSize, int target, int* returnSize) {
   int leftBorder=GetLeftBorder(nums,numsSize,target);
   int rightBorder=GetRightBorder(nums,numsSize,target);
   int *ans=(int*)malloc(sizeof(int)*2);
    ans[0]=leftBorder,
    ans[1]=rightBorder;
   *returnSize=2;
   return ans;
}

69. x的平方根

题目链接：69. x 的平方根 - 力扣（LeetCode）

题目描述：给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。

**注意：**不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

暴力求解

long int mySqrt(long int x) {
    long int ans=0; //设置为 long int型防止整数溢出
    for(long int i=1;i<=x/2+1;i++){
        if(i*i<=x&&(i+1)*(i+1)>x){
            ans=i;
            break;
        }
    }
    return ans;
}

二分查找

思路：寻找小于等于x的第一个平方根为整数的数的平方根

long int mySqrt(long int x) {
    long int left=1;
    long int right=(x>>1)+1;
    while(left<=right){
        long int mid=left+((right-left)>>1);
        if(mid*mid>x){ 
            right=mid-1;
        }else{ 
            left=mid+1;
        } 
    }
    return left-1; //因为若开根号不是整数，一定会出现结果为mid，但此时left=mid+1的情况
    //也可以直接返回right,当开根号不是整数时，此时right=mid-1
}

367. 有效的完全平方数

题目链接：367. 有效的完全平方数 - 力扣（LeetCode）

题目描述：给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。

不能使用任何内置的库函数，如 sqrt 。

提示：

1 <= num <= 2^31 - 1

注意整数溢出问题

暴力求解

bool isPerfectSquare(int num) {
   long int i;//防止整数溢出
   for(i=0;i<=num/2+1;i++){
    if(i*i==num){
        return true;
      }
   }
   return false;
}

二分查找

bool isPerfectSquare(int num) {
   long int left=1; 
   long int right=(num>>1)+1;//减少循环次数，因为num>3时，nmu一定小于等于num/2的平方
   while(left<=right){
    long  int mid=left+((right-left)>>1);
     if(mid*mid==num){
        return true;
     }else if(mid*mid>num){
         right=mid-1;
     }else{
        left=mid+1;
     }
   } 
   return false;
}