leetcode刷题之二分查找

最新推荐文章于 2024-07-16 14:00:27 发布
最新推荐文章于 2024-07-16 14:00:27 发布
阅读量414 收藏 2
点赞数
分类专栏： 数据结构和算法 文章标签： 二分法 二分查找 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39621037/article/details/102805744
版权
第一个错误的版本

在这里插入图片描述

参考代码
//使用查到第一个满足某条件的模板
// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int left=1,right=n;
        while(left<right){
            long long mid=left+(right-left)/2;
            if(isBadVersion(mid))
                right=mid;
            else
                left=mid+1;
        }
        return left;
    }
};
两个数组的交集II

在这里插入图片描述

参考代码
常规解法（哈希表）
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ret;
        if(nums1.size()==0||nums2.size()==0) return ret;
        map<int ,int > mmap;
        for(int x:nums1){
            if(mmap.find(x)==mmap.end()){
                mmap.insert(make_pair(x,1));
            }
            else{
                mmap[x]++;
            }
        }
        for(int x:nums2){
            if(mmap.find(x)!=mmap.end()){
                if(mmap[x]!=0){
                    ret.push_back(x);
                    mmap[x]--;
                }
            }
        }
        return ret;
    }
};
进阶解法

1.两个数组排序
2.设定两个指向这两个数组头部的指针，比较两个指针的元素是否相等
3.如果相等，元素push到返回值里，两个指针同时往前
4.如果不相等，元素小的指针往前(因为大元素可能在小元素数组里存在，但是小元素在大元素所在数组肯定不存在。因为已经排过序了。)

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ret;
        if(nums1.size()==0||nums2.size()==0) return ret;
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int p=0;
        int q=0;
        while(p<nums1.size()&&q<nums2.size()){
            if(nums1[p]==nums2[q]){
                ret.push_back(nums1[p]);
                p++;
                q++;
            }else if(nums1[p]<nums2[q]){
                p++;
            }else{
                q++;
            }
        }
        return ret;
    }
};

常规解法的时间和空间复杂度都是O(n)
进阶解法的时间复杂度是O(nlogn),空间复杂度是O(1)
进阶问题：
1.若给定的数组排好序了，则使用进阶解法
2.若nums1的大小比nums小很多，先排序，再查找
3.先将nums1的元素存在map中，再遍历nums2进行查找

扩充知识

在这里插入图片描述

判断子序列

在这里插入图片描述

参考代码
class Solution {
public:
    bool isSubsequence(string s, string t) {
        if(s.size()==0) return true;
        int a=0;
        for(int i=0;i<t.size();i++){
            if(s[a]==t[i])
                a++;
            if(a==s.size()) return true;
        }
        return false;
    }
};
后继挑战

后续挑战，输入量大，小写字母创建25的二维数组，存储t的坐标，这样就可以把s的判断直接转为坐标的判断，
dp[0]代表了存储了a出现在t的所有的位置,逐个字符判断s的字符顺序是否在t内，直接返回结果。
时间复杂度O(t.size()+2000)：分别为创建数组需要O(t.size()),
索引是递增的使用二分查找s的单个字符20次之内就可找到需要O(100* 20)。
适用大量的输入判断子序列。

bool isSubsequence(string s, string t) {        
    vector<vector<int>>dp(26);
    int tag=-1;//tag记录s中上一个字符在t中的位置
    for(int i=0;i<t.size();i++)
        dp[t[i]-'a'].push_back(i);
    for(int i=0;i<s.size();i++){
        int now=s[i]-'a';
        int left=0,right=dp[now].size()-1;
        //在t中找字符s[i],这个字符是第一个位置大于tag的
        while(left<right){
            int mid=(left+right)/2;
            if(dp[now][mid]>tag)
                right=mid;
            else
                left=mid+1;
        }
        //如果right<left说明dp[now].size()==0
        //dp[now][left]<tag已经遍历到了dp[now].size()-1那个元素
        if(right<left || dp[now][left]<tag)return false;
        tag=dp[now][left];
    
    }
    return true;
}
供暖器

在这里插入图片描述

参考代码
//解题思路：
//遍历所有House,记录当前house距离最近heater的距离，最后所有House的距离中的最大值即为所求
class Solution {
public:
    int findRadius(vector<int>& houses, vector<int>& heaters) {
        sort(houses.begin(),houses.end());
        sort(heaters.begin(),heaters.end());
        int maxDis=0;
        for(int c:houses){
            //找到第一个大于等于c的heater
            int left=0,right=heaters.size();
            while(left<right){
                long long mid=left+(right-left)/2;
                if(heaters[mid]>=c)
                    right=mid;
                else
                    left=mid+1;
            }
            //说明没有比C位置更大的heater
            if(left==heaters.size()) maxDis=max(maxDis,(c-heaters[left-1]));
            else if(heaters[left]==c) continue;
            else if(left==0) maxDis=max(maxDis,heaters[left]-c);
            else maxDis=max(maxDis,min(heaters[left]-c,c-heaters[left-1]));
        }
        return maxDis;
    }
};
山脉数组的峰顶索引

在这里插入图片描述

参考代码
class Solution {
public:
    int peakIndexInMountainArray(vector<int>& A) {
        int left=0,right=A.size()-1;
        if(A.size()<=2) return -1;
        while(left<=right){
            long long mid=left+(right-left)/2;
            if(A[mid]>A[mid-1]&&A[mid]>A[mid+1]) return mid;
            else if(A[mid]>A[mid-1])
                left=mid+1;
            else
                right=mid-1;
        }
        return -1;
    }
};
搜索旋转排序数组

在这里插入图片描述

参考代码
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0,right=nums.size()-1;
        while(left<=right){
            long long mid=left+(right-left)/2;
            if(nums[mid]==target) return mid;
            else if(nums[mid]>=nums[left]){
                //如果前半部分有序,注意是大于等于,当等于时mid==left,此时是一个元素，也认为有序，否则会出错
                if(nums[left]<=target&&target<nums[mid])
                    right=mid-1;
                else
                    left=mid+1;
            }else{
            //后半部分有序
                if(nums[mid]<target&&target<=nums[right])
                    left=mid+1;
                else
                    right=mid-1;
            }
        }
        return -1;
    }
};
搜索旋转排序数组 II

在这里插入图片描述

参考代码
class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if(nums.size()==0) return false;
        int left=0,right=nums.size()-1;
        while(left<=right){
            long long mid=left+(right-left)/2;
            if(nums[mid]==target) return true;
            else if(nums[mid]==nums[left]&&nums[mid]==nums[right]){//中间与两边的值相等时，分不清前面有序还是后面有序
                left=left+1;
                right=right-1;
            }
            else if(nums[mid]>=nums[left]){
                if(nums[mid]>target&&target>=nums[left])
                    right=mid-1;
                else
                    left=mid+1;
            }else if(nums[mid]<nums[left]){
                if(nums[mid]<target&&target<=nums[right])
                    left=mid+1;
                else
                    right=mid-1;
            }
        }
        return false;
    }
};
pow(x,n)

在这里插入图片描述

参考代码
class Solution {
public:
    double myPow(double x, int n) {
        if(n==0) return 1;
        long long N=n;
        if(n<0){
            x=1/x;
            N=-N;//不能写成N=-n,因为若n=-x^31,此时会越界
        }
        double ret=1,base=x;
        while(N){
            if(N&1){//若N为奇数
                ret*=base;
            }
            base*=base;
            N>>=1;//N右移一位
        }
        return ret;
    }
};
搜索二维矩阵

在这里插入图片描述

参考代码
//将二维矩阵展开进行二分查找
class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0) return false;
        int n=matrix.size();
        int m=matrix[0].size();
        int left=0,right=n*m-1;
        while(left<=right){
            long long mid=left+(right-left)/2;
            int row=mid/m,col=mid%m;
            if(matrix[row][col]==target) return true;
            else if(matrix[row][col]>target)
                right=mid-1;
            else
                left=mid+1;
        }
        return false;
    }
};
寻找旋转排序数组中的最小值

在这里插入图片描述

参考代码
class Solution {
public:
    int findMin(vector<int>& nums) {
        if(nums.size()==1) return nums[0];
        int left=0,right=nums.size()-1;
        if(nums[left]<nums[right]) return nums[left];
        while(left<=right){
            long long mid=left+(right-left)/2;
            if(nums[mid]>nums[mid+1])   //因为mid取得是左中位数，所以mid+1一定不会越界
                return nums[mid+1];
            if(nums[mid]<nums[mid-1])   //放在第二个判断，一定不能放在第一个判断,因为不能保证mid-1>=0,而当只有两个元素是会出现mid-1=-1的情况，此时第一个判断条件可以直接得到结果，不会进入该判断
                return nums[mid];
            if(nums[mid]>nums[0])
                left=mid+1;
            else
                right=mid-1;
        }
        return nums[left];
    }
};
寻找峰值(?)

在这里插入图片描述

参考代码
//解题关键：只要数组中存在一个元素比相邻元素大，那么沿着它一定可以找到一个峰值
class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left=0,right=nums.size()-1;
        while(left<right){
            long long mid=left+(right-left)/2;
            if(nums[mid]>nums[mid+1])
                right=mid;
            else
                left=mid+1;
        }
        return left;
    }
};
长度最小的子数组

在这里插入图片描述

参考代码(双指针)
//定义左右指针p,q
//若[p,q]区间内的元素和大于等于s，则p++
//若[p,q]区间内的元素和小于s，则q++
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        if(nums.size()==0) return 0;
        int sum=nums[0];
        int len=INT_MAX;
        int p=0,q=0;
        while(true){
            if(sum>=s)
            {
                len=min(len,(q-p)+1);
                sum-=nums[p];
                p++;
                if(p>=nums.size()) break;
            }else{
                q++;
                if(q>=nums.size()) break;
                sum+=nums[q];
            }
        }
        return len==INT_MAX?0:len;
    }
};
搜索二维矩阵 II

在这里插入图片描述

参考代码
解法一（排除法）
class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0)
            return false;
        int row=0;
        int col=matrix[0].size()-1;
        while(row<matrix.size()&&col>=0){
            if(matrix[row][col]<target)
                row++;
            else if(matrix[row][col]>target)
                col--;
            else
                return true;
        }
        return false;
    }
};
解法二：递归二分法
//解题思路:我们可以将已排序的二维矩阵划分为四个子矩阵，其中两个可能包含目标，其中两个肯定不包含
//我们沿着索引行的矩阵中间列，则目标值要么在中间列上，要么在左上和右下举矩阵中
H指数II

在这里插入图片描述

参考代码
//套用模板查找第一个满足条件的位置，注意要考虑不存在的情况
class Solution {
public:
    int hIndex(vector<int>& citations) {
        if(citations.size()==0) return 0;
        if(citations.size()==1&&citations[0]) return 1;
        else if(citations.size()==1&&citations[0]==0) return 0;
        int left=0,right=citations.size()-1;
        while(left<right){
            long long mid=left+(right-left)/2;
            int num=citations.size()-mid;
            if(citations[mid]>=num)
                right=mid;
            else
                left=mid+1;
        }
        int ret=citations.size()-left;
        return (ret<=citations[left])?ret:0;
    }
};
寻找重复数

在这里插入图片描述

参考代码
哈希表法
class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        unordered_map<int,int> mmap;
        for(int x:nums){
            if(mmap.find(x)==mmap.end()){
                mmap.insert(make_pair(x,1));
            }else{
                mmap[x]++;
                if(mmap[x]>1) return x;
            }
        }
        return -1;
    }
};
二分法

在这里插入图片描述

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        //这里的left,right并不是索引下标，而是nums的取值范围[left,right]，初始时的取值范围是[1,n]
        int left=1,right=nums.size()-1;
        while(left<right){
            //这里的mid是指中位数，不是索引
            long long mid=left+(right-left)/2;
            int counter=0;
            //统计有多少个小于等于mid的数，若没有重复的数，则小于等于mid的数应当有mid个
            for(int num:nums)
                if(num<=mid)
                    counter++;
            if(counter>mid)
                right=mid;
            else
                left=mid+1;
        }
        return left;
    }
};
有序矩阵中第k小的元素

在这里插入图片描述

参考代码

解题思路:
首先考虑一维数组的情况:
[1,3,2,5,4,6,8,9] k=3
首先计算出中位数(1+9)/2=5,统计小于等于5的个数为5>=3，所以目标值在[1,5]范围内
再计算中位数(1+5)/2=3,同理统计个数有3>=3,所以目标值在[1,3]内
再计算中位数(1+3)/2=2,统计个数有2<3，所以目标值在[3,3],此时只有一个数，所以目标值就是3

二维数组同理,有序二维矩阵的最小值为最左上角的数，最大值为右下角的数

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int len=matrix.size();
        int left=matrix[0][0],right=matrix[len-1][len-1];
        while(left<right){
            long long mid=left+(right-left)/2;
            //统计小于等于mid的个数
            int j=matrix[0].size()-1;
            int counter=0;
            for(int i=0;i<len;i++){
                while(j>=0&&matrix[i][j]>mid) j--;
                counter+=(j+1);
            }

            if(counter>=k)
                right=mid;
            else
                left=mid+1;
        }
        return left;
    }
};

疑问：如何保证每次迭代求得的mid一定在有序矩阵中

总结

1.使用二分模板查找满足某条件的元素时，若该元素不一定存在，一定要对边界情况进行讨论。
2.对于一些找目标值的问题，若给出的数组中数的取值范围确定，则可以考虑对数的值的二分查找，而不是对索引的二分查找，比如寻找重复数问题，有序矩阵中第k小的元素
3.二分法的使用需要数据是有序的，同时在编写的时候一定要避免出现死循环

lingqing97
关注
专栏目录
【Leetcode刷题】二分查找
Joe的博客
12-28 3773
二分法 二分法的两个主要实现方式：双开区间和双闭区间（单开单闭区间则是比较雷同的做法了，而且其不太适用到其他算法，暂不考虑）。 双开区间 二分查找（Q704) 双开区间的意思是，我们在整个实现过程中，只考虑mid指针元素的值和target的关系，不考虑head和tail是否和target相等，因为我们要预先保证它们俩都和target不相等。 因此算法步骤是： 如果target处在区间外，直接返回-1； 如果整个数组的head或者tail等于target，直接返回对应的坐标； 处理(head, tail)这
1_leetcode刷题指南.pdf
05-08
- **猜数字游戏**：涉及到了二分查找算法。 - **加油站问题**：需要对数组进行累加，并判断是否存在某个点之后可以到达数组末尾。 - **杨辉三角**：涉及到数组的二维结构模拟和组合数学。 ### 字符串类 字符串类的...
二分搜索 设a[0:n-1]是一个已排好序的数组。请改写二分搜索算法，使得当搜索元素x不在数组中时，返回小于x的最大元素的位置I和大于x的最大元素位置j
10-08
设a[0:n-1]是一个已排好序的数组。请改写二分搜索算法，使得当搜索元素x不在数组中时，返回小于x的最大元素的位置I和大于x的最大元素位置j。
LeetCode-搜索二维矩阵
热门推荐
ggboy的博客
08-10 4万+
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。 该矩阵具有如下特性： 每行中的整数从左到右按升序排列。 每行的第一个整数大于前一行的最后一个整数。 示例 1: 输入: matrix = [ [1, 3, 5, 7], [10, 11, 16, 20], [23, 30, 34, 50] ] target = 3 输出: true 示例 2:...
二分查找^_^
最新发布
ZCSDNHJKS的博客
07-16 878
输入数据：第一行，一个整数 n ，代表数组元素个数（n≤10^6）第二行，n 个数，代表数组的 n 个递增元素（1≤数组元素值≤10^8 ）第三行，一个整数 x，代表要查找的数（0≤x≤10^8）输出x 在数组中的位置，或者 -1。输入数据：第一行，一个整数 n ，代表数组元素个数（n≤10^6）第二行，n 个数，代表数组的 n 个递增元素（1≤数组元素值≤10^8 ）第三行，一个整数 x，代表要查找的数（0≤x≤10^8）输出x 在数组中的位置，或者 -1。问题分析：解法一：暴力，样例没问题，提交0分。
leetcode二分查找问题整理
weixin_34342578的博客
03-24 157
自从做完leetcode上的三道关于二分查找的题后，我觉得它是比链表找环还恶心的题，首先能写出bugfree代码的人就不多，而且可以有各种变形，适合面试的时候不断挑战面试者，一个程序猿写代码解决问题的能力都能在这个过程中考察出来。 在有序数组中寻找等于target的数的下标，没有的情况返回应该插入的下标位置 ：http://oj.leetcode.com/problems/search-inse...
[算法][LeetCode]Search a 2D Matrix——二维数组的二分查找
隐之狐的专栏
11-01 1669
题目要求 Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:   Integers in each row are sorted from left to right.The first intege
【leetcode系列】【算法】【面试题】二维数组中的查找(利用栈的分治 + 二分查找)
songyuwen0808的博客
04-15 282
题目： 题目链接：https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/ 解题思路： 方法一：线性查找 从矩阵的右上角开始查找，流程如下： 如果目标值大于当前值，则目标值大于当前行前面的所有值，所以向下查找 如果目标值小于当前值，则目标值小于当前列下面的所有值，所以向左查找 这样子能...
LeetCode刷题笔记.rar
07-05
在LeetCode中，常见的算法题型涉及排序（快速排序、归并排序、堆排序等）、搜索（二分查找、深度优先搜索、广度优先搜索等）、动态规划、贪心算法、回溯法、分治法等。动态规划通常用于解决最优化问题，如背包问题、...
algorithm-learning:leetcode刷题（Java，Python）和算法书籍
03-18
- **排序与搜索**：包括快速排序、归并排序、堆排序、二分查找等基础算法，这些都是解决很多问题的基础。 - **图论**：如深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim或Kruskal）、最短路径...
谷歌高畅Leetcode刷题笔记.pdf
08-04
对于二分查找，不仅涵盖了基本的二分查找算法，还讨论了求开方、查找区间以及旋转数组查找数字等变种。 在数据结构方面，书中介绍了C++中的STL（标准模板库）及其各容器的使用。包括数组、栈、队列、单调栈、优先...
Python查找数组中数值和下标相等的元素示例【二分查找】
09-19
主要介绍了Python查找数组中数值和下标相等的元素,结合实例形式分析了Python基于二分查找针对数组查找相关实现技巧,需要的朋友可以参考下
Leetcode刷题记—— Search a 2D Matrix(在二维数组里查找)
爱胡椒的小白兔呢
12-27 363
一、题目叙述： Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties: Integers in each row are sort
二分查找解决数组元素定位问题
aijianxie8808的博客
11-01 205
二分查找（Binary Search） 给定包含 n 个元素的已排序数组 sorted_array[]，求给定元素 x 的位置。 递归方式（Recursive）实现 迭代方式（Iterative）实现 给定包含 n 个元素的已排序数组 sorted_array[]，求小于等于给定元素 x 的最近位置（Floor Value）。 给定包含 n 个元素的已排序数组 ...
二分查找灵活应用 —— LeetCode-287.寻找重复数、LeetCode-378.有序矩阵中第K小的元素
qq_24210431的博客
05-17 238
二分查找描述 二分查找是一种在排序的线性表中常用的查找特定值的查找方式。它的常规过程是这样的： 对于一个长度为n的线性表nums，我们在要寻找的目标值target的可能所在的区域nums[left,right]中对它进行寻找； 最开始时，整个nums都是可能区域，因此初始化left=0,right=n-1分别指向线性表nums的最左端的下标和最右端的下标； 根据left和right计算得到mid=(left+right)/2，即可能区域的中间位置的下标，若nums[mid]==target就找到了目标值，
数组下的二分查找
weixin_42720350的博客
12-15 1364
相信大家对二分查找都不陌生，或者对其原理大概有个了解，但是为什么很多同学对于二分查找法一看就会，一写就废？ 通过几道题目，让同学们对二分查找有更深刻的认识。接下来就是深度剖析的时刻！ 题目1：给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 示例1： 输入: nums = [-1,0,3,5,9,12], target = 5 输出: 3 解释: 5 出现在 ...
查找算法-二分查找
Kevin-Ding的博客
03-09 236
7、查找算法 7.1 介绍 常用的查找算法有四种： 线性查找（顺序查找） 二分查找（折半查找） 插值查找 斐波那契查找 7.2 线性查找 给定一个数列，和一个带查找的元素，线性查找方法即将整个数列进行遍历，分别将遍历到的元素与待查找的目标值进行比较，如果相等，则表示在数列中找到了对应的元素，直接返回该值对应的下标，如果遍历结束没有找到目标值，则返回-1。 以数列{1,23,43,25,66,47,97,242,13,56,70,33}为例，查找目标值为13，代码实现如下： package com.kev
【算法笔记】数组篇-二分查找
computs的博客
01-12 725
二分查找 前提是数组有序 (假设数组非递减排列) 步骤： 设左右指针left，right 找出中间的位置，如何判断该位置的值是否等于target 若nums[mid]==target,则返回该位置下标 若nums[mid]>target，则right=mid-1 若nums[mid]<target,则left=mid+1 mid的求法：mid=left+(right-left)/2或mid=left+((right-left)>>1) 注意：算数运算符的优先级比移位运算符高。 对
二分查找
qq_33457548的博客
09-21 76
目录 1.搜索旋转排序数组 2.在排序数组中查找元素的第一个和最后一个位置 1.搜索旋转排序数组 class Solution { public: int search(vector<int>& nums, int target) { if (nums.size() <= 0) return -1; ...
LeetCode刷题笔记：二分查找与移除元素算法解析
二分查找和27.移除元素两道题目，旨在帮助学习算法和数据结构的程序员或学生提升编程能力。 在704.二分查找题目中，给定一个有序整型数组`nums`和目标值`target`，任务是找到`target`在数组中的下标，如果不存在则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值