17道题带你理解二分查找

最新推荐文章于 2023-01-04 17:47:21 发布
最新推荐文章于 2023-01-04 17:47:21 发布
阅读量1.1k 收藏 22
点赞数 22
分类专栏： Leetcode 文章标签： leetcode 算法 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45627369/article/details/121349596
版权

不太会的可以先看看二分查找的模板
点这里

最需要注意的是二分查找的分界线并不止局限于大于等于小于，而是对某种性质的一种分界

1.Leetcode704. 二分查找

在这里插入图片描述

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

2.Leetcode69. Sqrt(x)

在这里插入图片描述

class Solution {
public:
    int mySqrt(int x) {
       long long l=0,r=x;
       while(r>l){
           long long mid=(l+r+1)/2;
           if(mid<=x/mid){
               l=mid;
           }else{
               r=mid-1;
           }
       }  
       return l;
    }
};

3.Leetcode374. 猜数字大小

在这里插入图片描述

class Solution {
public:
    int guessNumber(int n) {
        long long  l=1,r=n;
        while(l<r){
            long long  mid=(l+r)/2;
            if(guess(mid)==0||guess(mid)==-1){
                r=mid;
            }else {
                l=mid+1;
            }
        }
        return r;

    }
};

4.Leetcode153. 寻找旋转排序数组中的最小值

在这里插入图片描述
在这里插入图片描述

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

5.Leetcode33. 搜索旋转排序数组

在这里插入图片描述
这道题很特别，相较于Leetcode153.寻找旋转排序数组中的最小值
这里找的是目标值target，而不是nums[0],但是target对于153中nums[0]划分的界限（利用最后一个数x作为分界点，小于等于x在nums[0]右边，大于x在nums[0]左边）来说，在这里难以找到循环数组中target是什么性质的分界线，还是需要借助nums[0]和target的位置关系,直接分情况讨论

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int len=nums.size(),ans;
        int st=find1(nums,0,len-1,nums[len-1]);
        printf("st=%d\n",st);
        if(nums[len-1]>=target){
            ans=find2(nums,st,len-1,target);
        }else{
            ans=find2(nums,0,st-1,target);
        } 

        if(nums[ans]!=target)return -1;
        return ans;
        
    }
    //查找nums[0]的位置，nums[0]的左边都>nums[len-1],右边都小于等于nums[len-1]
    int  find1(vector<int>&nums,int l,int r,int divide){
        while(l<r){
            int mid=(l+r)/2;
            if(nums[mid]<=divide){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return l;

    }
    //查找target位置，此时查找区间一定是递增的
    int find2(vector<int>&nums,int l,int r,int divide){
        while(l<r){
            int mid=(l+r)/2;
            if(nums[mid]>=divide){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return l;

    }
};

6.Leetcode278. 第一个错误的版本

在这里插入图片描述

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        long long l=1,r=n;
        while(l<r){
            long long mid=(l+r)/2;
            if(isBadVersion(mid)){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return l;
    }
};

7.Leetcode162. 寻找峰值

在这里插入图片描述
参考Leetcode作者：guanpengchn
首先要注意题目条件，在题目描述中出现了 nums[-1] = nums[n] = -∞，这就代表着只要数组中存在一个元素比相邻元素大，那么沿着它一定可以找到一个峰值
往递增的方向上，二分，一定能找到波峰，往递减的方向只是可能找到，也许没有。
根据上述结论，我们就可以使用二分查找找到峰值
查找时，左指针 l，右指针 r，以其保持左右顺序为循环条件
根据左右指针计算中间位置 m，并比较 m 与 m+1 的值，如果 m 较大，则左侧存在峰值，r = m，如果 m + 1 较大，则右侧存在峰值，l = m + 1

时间复杂度：O(logN)

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

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

在这里插入图片描述

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
         vector<int>ans;
         if(nums.size()==0){
             ans.push_back(-1);
             ans.push_back(-1);
             return ans;
         }
         int l=findl(nums,target);
         int r=findr(nums,target);
         if(l==-1||r==-1){
            ans.push_back(-1);
            ans.push_back(-1);
         }else{
             ans.push_back(l);
             ans.push_back(r);
         }
         return ans;

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

9.Leetcode658. 找到 K 个最接近的元素

在这里插入图片描述
法一：直观地，我们可以将数组中的元素按照与目标 x 的差的绝对值排序，排好序后前 k 个元素就是我们需要的答案。
法二：
①如果target<nums[0],返回前k个数
②如果target>nums[len-1]，返回后k个数
③利用二分找到最接近的数，然后不断比较–left,–right与target的绝对值，直到找够k个最小的

class Solution {
public:
    const int N=1e4+10;
    vector<int>ans;
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        int len=arr.size();
        if(x<=arr[0]){
            int i=0;
            while(k--){
              ans.push_back(arr[i++]);
            }
        }else if(x>=arr[len-1]){
            int i=len-1;
            while(k--){
              ans.push_back(arr[i--]);
            }
        }else{
            int index=find(arr,x);
            //找到最接近的值的下标
            if(index-1>=0&&abs(arr[index-1]-x)<=abs(arr[index]-x))index--;//左优先，所以这里是小于等于
            if(index+1<len&&abs(arr[index+1]-x)<abs(arr[index]-x))index++;
           
            ans.push_back(arr[index]);
            int l=index-1,r=index+1;
            while(--k&&l>=0&&r<len){
                if(abs(arr[l]-x)<=abs(arr[r]-x)){
                    ans.push_back(arr[l--]);
                }else{
                     ans.push_back(arr[r++]);
                }
            }
            while(k--){
                if(l>=0)ans.push_back(arr[l--]);
                if(r<len)ans.push_back(arr[r++]);
            }
            

        }
        sort(ans.begin(),ans.end());
        return ans;
        

    }
    int find(vector<int>&arr,int x){
          int l=0,r=arr.size()-1;
          while(l<r){
              int mid=(l+r)/2;
              if(arr[mid]>=x){
                  r=mid;
              }else{
                  l=mid+1;
              }
          }
          return l;
    }
};

10.Leetcode50. Pow(x, n)

在这里插入图片描述
这道用快速幂好一些

class Solution {
public:
    const double INF=0x3f3f3f3f;
    double myPow(double x, long n) {
       bool flag=false;
       if(n<0)flag=true;
       if(flag)n=-n;
       double res=qmi(x,n);
       if(flag)return 1/res;
       return res;
    }
    double qmi(double m,long k){
       double res=1,t=m;
       while(k){
           if(k&1)res=res*(double)t;
           t=t*t;
           k=k>>1;
       }
       return res;
    }
};

11.Leetcode367. 有效的完全平方数

在这里插入图片描述

class Solution {
public:
    bool isPerfectSquare(int num) {
        long long l=1,r=num;
        while(l<r){
            long long mid=(l+r)/2;
            if(mid>=num/mid)r=mid;
            else l=mid+1;
        }
        if(l*l==num)return true;
        return false;

    }
};

12.Leetcode744. 寻找比目标字母大的最小字母

在这里插入图片描述

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

13.Leetcode154. 寻找旋转排序数组中的最小值 II

14.Leetcode349. 两个数组的交集

在这里插入图片描述
法一:hash
法二：排序加双指针
法三：排序+二分

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
         sort(nums1.begin(),nums1.end());
         sort(nums2.begin(),nums2.end());
         int len1=nums1.size();
         int len2=nums2.size();
         vector<int>ans;
         for(int i=0,j=0;i<len1;i++){
             j=i;
             while(j<len1-1&&nums1[j]==nums1[j+1])j++;
             bool res=search(nums1[j],nums2,len2);
             if(res)ans.push_back(nums1[j]);
             i=j;
         }
         return ans;

    }
    bool search(int target,vector<int>& nums2,int len){
        int l=0,r=len-1;
        while(l<r){
            int mid=(l+r)/2;
            if(nums2[mid]>=target)r=mid;
            else l=mid+1;
        }
        if(nums2[l]==target)return true;
        return false;

    }
};

15.Leetcode350. 两个数组的交集 II

在这里插入图片描述

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
         int len1=nums1.size();
         int len2=nums2.size();
         if(len1>len2){
             return intersect(nums2,nums1);
         }
         unordered_map<int,int>m;
         for(int num:nums1){
             ++m[num];
         }
         vector<int>ans;
         for(int num:nums2){
             if(m.count(num)){
                 ans.push_back(num);
                 --m[num];
                 if(m[num]==0)m.erase(num);
             }
         }
         return ans;     

    }
};

16.Leetcode167. 两数之和 II - 输入有序数组

在这里插入图片描述

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int>ans;
       int len=numbers.size();
       int i=0,j=len-1;
       int prei=0,prej=len-1;
      
       while(i<=j){
          if(numbers[i]+numbers[j]==target){
              ans.push_back(i+1);
              ans.push_back(j+1);
              break;
          }else if(numbers[i]+numbers[j]<target){
              i++;
              if(i==prei)break;
              prei=i;
              
          }else{
              j--;
              if(j==prej)break;
              prej=j;
          }
       }
       return ans;
    }
};

17.Leetcode287. 寻找重复数

根据抽屉原理，我们定义cnt[i]表示nums 数组中小于等于 i 的数有多少个.
假设我们重复的数是 target，那么 [1,target−1]里的所有数满足 cnt[i]≤i，[target,n] 里的所有数满足 cnt[i]>i，具有单调性。

数字是在1~ n之间的乱序，给的数组长度是n+1，所以通过抽屉原理可知：必定有一个数字重复。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int len=nums.size();
        sort(nums.begin(),nums.end());
        int l=0,r=len-1;
        while(l<r){
            int mid=(l+r)/2;
            int cnt=0;
            for(int i=0;i<len;i++){
                cnt+=nums[i]<=mid;
            }
            // 数的范围为1~n,1~n中小于等于4的数只有1，2，3，4一共4个，根据抽屉原理，小于等于 4 的个数如果严格大于 4 个，此时重复元素一定出现在 [1..4] 区间里
            if(cnt>mid){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return nums[l];
    }
};
折叠的饼干
关注
  • 22
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
备战蓝桥杯-二分查找（附多道题解和详细分析）
CrazyRabbitttt
01-03 8335
本文主要是面向准备明年蓝桥杯和学习算法的同学，包含了很多到二分查找的题目和详细的分析，相信看过这篇文章，你对于二分会有更加深刻的理解
二分查找 & 二分答案 万字详解，超多例题，带你学透二分。
热门推荐
Mr_dimple的博客
03-17 7万+
很多人对二分很困惑，可能二分的边界很难掌握，也许是判断条件难写... 很幸运，你找到了这篇文章，仔细看下去，这篇文章将带你**学透二分**！！！
二分查找各种类型例题
qq_41358574的博客
01-04 663
普通二分查找和进阶二分查找
二分查找题目汇总
雪糕cool的博客
07-12 1862
二分查找题目汇总
数据结构之二分查找
摩尔的博客
05-12 1829
上面我们介绍了顺序查找，但是它的时间复杂度为o(n)让人很受伤啊，所以有了二分查找，二分查找是一个时间复杂度为O(logn)的算法，当然都是说的一般情况下，二分、二分，看名字就知道它的核心是什么了，就是不断地额逼近查找值。 代码#include<stdio.h> #define max_len 20 typedef struct { int r[max_len+1]; int le
二分查找算法题个人总结
01-04
这三种场景分别对应了二分查找的不同应用，理解这些变体有助于我们在实际编程中灵活运用二分查找算法。在实际编程中，还需要注意边界条件和异常处理，确保算法的健壮性。此外，对于大型数据集，二分查找的时间复杂度...
二分查找解题
11-02
本篇文章将深入探讨二分查找算法的递归实现，并结合大量的注释帮助理解。 首先，我们要明白二分查找的基本步骤： 1. 找到数组的中间元素。 2. 如果中间元素就是目标值，查找结束。 3. 如果目标值小于中间元素，...
计算机二级C语言机试题库 100道
03-28
理解和掌握常见的排序（如冒泡、选择、插入、快速等）和搜索（如线性、二分等）算法，以及栈、队列、链表等基本数据结构。 通过这100道试题的练习，考生可以全面复习C语言的主要概念和技能，提升编程能力，为计算机...
数据结构考研1800道习题保你考研过关
01-03
此外，还需要深入理解各种排序算法（如冒泡排序、选择排序、插入排序、快速排序、归并排序等）和查找算法（如线性查找、二分查找、哈希查找）的工作原理及效率分析。 接下来，高级数据结构如红黑树、B树、AVL树、图...
Python二级模拟试题
08-23
10. **数据结构与算法**：掌握常见数据结构如栈、队列、堆等，理解简单算法如排序（冒泡、选择、插入、快速等）、查找（顺序、二分查找等）。 11. **Python标准库的使用**：如os模块用于操作系统交互，sys模块获取...
[PTA]6-13 折半查找
Spring-_-Bear 的 CSDN 博客
06-28 906
给一个严格递增数列，函数 int Search_Bin(SSTable T, KeyType k) 用来二分地查找 k 在数列中的位置。其中 T 是有序表，k 是查找的值。
6-13 折半查找 (15分)
半零落的博客
03-22 1741
给一个严格递增数列，函数int Search_Bin(SSTable T, KeyType k)用来二分地查找k在数列中的位置。 函数接口定义： int Search_Bin(SSTable T, KeyType k) 其中T是有序表，k是查找的值。 裁判测试程序样例： #include <iostream> using namespace std; #de...
leecode第三十三题（搜索旋转排序数组）
weixin_30247307的博客
03-24 91
class Solution { public: int search(vector<int>& nums, int target) { int len=nums.size(); if(len==0)//两种输入的特殊情况 return -1; if (len...
leetcode—22.二分查找题目leetcode总结
柳杰的博客
05-04 1136
文章目录引言查找一个数寻找最左边的满足条件的值面试题 08.03. 魔术索引寻找最右边的满足条件的值寻找最左插入位置35. 搜索插入位置34. 在排序数组中查找元素的第一个和最后一个位置寻找最右插入位置的情况局部有序(先降后升或先升后降)33. 搜索旋转排序数组81. 搜索旋转排序数组 II面试题 10.03. 搜索旋转数组153. 寻找旋转排序数组中的最小值二维数组的二分查找74. 搜索二维矩阵240. 搜索二维矩阵 II 引言   二分查找的问题定义为： 给定一个由数字组成的有序数组nums，并给你一
一个90%程序员写不对的算法——二分查找
yc2zgh1314的博客
05-19 817
一个90%的程序员写不对的程序，一个面试高频出现的面试题，一个开发中用之甚广的算法，一个最能体现程序员素质的代码，它就是二分查找。
7道题解决二分查找问题
lzh824359508的博客
06-17 259
二分查找顺序数组搜索一个值搜索插入位置排序数组查找元素第一个和最后一个位置找第一个大于目标元素的索引找最后一个比目标元素小的索引搜索旋转的排序数组搜索旋转的有重复排序数组找旋转数组最小值 顺序数组搜索一个值 二分查找最基本的思想，查找的区间必须有序 本文全部按照闭区间来查找，此时while里面条件应该写为l<=r 若按开区间查找（r=nums.size()），此时while里面条件应该写为l<r 返回值-1表示未找到目标 class Solution { public: int sea
leetcode 162. Find Peak Element-查找峰元素|二分查找
hdtopku
06-05 4186
原题链接：162. Find Peak Element 【思路-Java、Python】 二分查找 题目中已经说明，最左端和最右端元素均无限小，中间元素比两侧都要大，那么本题中一定存在一个峰元素。所以不管中间有多少波峰，只要找到峰元素，我们只需找到刚刚开始下降而未下降的位置。采用二分查找，查出这样一个位置即可，我们知道二分查找要比较的是 target 元素，本题的 target 元素是 mid
寻找重复数-LeetCode287
jaaccck的博客
04-24 766
一、题目描述 给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。 假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。 注意！！！ ：你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。 示例一： 输入：nums = [1,3,4,2,2] 输出：2 二、解题思路（这道题的解题思路很难想到，以前做的题从来没有碰到过。） （1）题目有明确要求：设计的解决方案必须..
数据结构算法——数组问题（以LeetCode数组题为例）
枫陵的博客
05-29 584
一. 数组的定义 在程序设计中，为了处理方便，常常需要把具有相同类型的若干元素按有序的形式组织起来，这种形式就是数组（Array）。数组是程序中最常见、也是最基本的数据结构。 对数组进行处理需要注意以下特点： 首先，数组会利用索引来记录每个元素在数组中的位置，且在大多数编程语言中，索引是从 0 算起的。我们可以根据数组中的索引，快速访问数组中的元素。事实上，这里的索引其实就是内存地址。 其次，作为线性表的实现方式之一，数组中的元素在...
二分查找pta函数题
最新发布
09-11
二分查找是一种常用的查找算法，它可以在有序数组中...记住，在编写代码之前，需要先理解二分查找的原理和基本步骤。这样你才能更好地解决相关的函数题。 希望这些信息对你有帮助！如果你还有其他问题，我会尽力回答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值