二分查找题目

已于 2022-03-01 15:35:41 修改
阅读量495 收藏 2
点赞数
文章标签： leetcode 二分查找
于 2022-02-27 22:41:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43536978/article/details/123172091
版权
这篇博客探讨了二分查找算法在多种信息技术问题中的应用，包括查找数组中的特定元素、确定数字是否占多数、寻找数组中的不动点、猜数字游戏、找缺失正整数、目标下标定位、早餐组合计算、错误版本定位、采购方案优化以及排序数组操作等。通过这些实例展示了二分查找如何有效提高算法效率。
摘要由CSDN通过智能技术生成

二分查找

检查一个数是否在数组中占绝大多数


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

class Solution {
    public int leftest(int[] nums,int target){
        int left=0,right=nums.length-1;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(nums[mid]>=target){
                right=mid;
            }
            else{
                left=mid+1;
            }
        }
        return left;
    }
    public int rightest(int[] nums,int target){
        int left=0,right=nums.length-1;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(nums[mid]>target){
                right=mid;
            }
            else{
                left=mid+1;
            }
        }
        return left;
    }
    public boolean isMajorityElement(int[] nums, int target) {
        
        //二分找出等于target最左的位置
        int left=leftest(nums,target);

        //二分找出等于target最右的位置
        int right=rightest(nums,target);
        if(left==right){
            return false;
        }
        return right-left+1>nums.length/2;
    }
}

在这里插入图片描述



不动点


在这里插入图片描述

在这里插入图片描述

class Solution {
    public int fixedPoint(int[] arr) {
        int left=0,right=arr.length-1;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(arr[mid]==mid){
                right=mid;
            }else if(arr[mid]<mid){
                left=mid+1;
            }else{
                right=mid-1;
            }
            
        }
        
        return left==arr[left]?left:-1;
    }
}

在这里插入图片描述



猜数字大小


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

/** 
 * Forward declaration of guess API.
 * @param  num   your guess
 * @return 	     -1 if num is lower than the guess number
 *			      1 if num is higher than the guess number
 *               otherwise return 0
 * int guess(int num);
 */

public class Solution extends GuessGame {
    public int guessNumber(int n) {
        
        int left=1,right=n;
        int mid=0;
        while(left<=right){
            mid=left+((right-left)>>1);
            if(guess(mid)==0)return mid;
            else if(guess(mid)>0){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;
    }
}

在这里插入图片描述

第 k 个缺失的正整数


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

class Solution {
    public int findKthPositive(int[] arr, int k) {
        int left=0,right=arr.length-1;
        if(arr[arr.length-1]==arr.length)return arr[arr.length-1]+k;
        if(arr[0]-1>=k){
            return k;
        }else{
            k-=(arr[0]-1);
        }
        
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(left==mid)break;
            //if(k==0)break;
            else if(arr[mid]-arr[left]-(mid-left)>0){
                if(arr[mid]-arr[left]-(mid-left)<k){
                    k-=arr[mid]-arr[left]-(mid-left);
                    left=mid;
                }else{
                    right=mid;
                }    
            }else{
                left=mid;
            }
        }
        if(left<arr.length-1){
            if(arr[left]+1==arr[left+1]){
                return arr[arr.length-1]+k;
            }else{
                return arr[left+1]-arr[left]-1>=k?arr[left]+k:arr[left+1]+(k-(arr[left+1]-arr[left]-1));
            }
        }
        return arr[left]+k;
    }
}

在这里插入图片描述



找出数组排序后的目标下标


在这里插入图片描述

在这里插入图片描述

class Solution {
    public int leftest(int[] nums,int target){
        int left=0,right=nums.length-1;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(nums[mid]<target){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;
    }
    public int rightest(int[] nums,int target){
        int left=0,right=nums.length-1;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(nums[mid]<=target){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;
    }
    public List<Integer> targetIndices(int[] nums, int target) {
        Arrays.sort(nums);
        //二分找出等于target最左的位置
        int left=leftest(nums,target);
        //二分找出等于target最右的位置
        int right=rightest(nums,target);
        List<Integer>list=new ArrayList<>();
        for(int i=left;i<=right;++i){
            if(nums[i]==target){
                list.add(i);
            }
        }
        return list;

    }
}

在这里插入图片描述



早餐组合


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

class Solution {

    //O(NlogN)
    public int breakfastNumber(int[] staple, int[] drinks, int x) {
        //排序
        Arrays.sort(staple);
        Arrays.sort(drinks);
        int ans=0;
        int index=0;
        for(int s=0;s<staple.length;++s){
            if(staple[s]>=x)break;
            int rest=x-staple[s];
            //二分查找drinks数组中大于rest的最左的位置
            index=getIndex(drinks,rest);
            if(rest<drinks[index]){
                ans+=index;
            }else{
                ans+=index+1;
            }
            ans%=1000000007;
        }
        return ans%1000000007;
    }
    public int getIndex(int[] drinks,int x){
        int left=0,right=drinks.length-1;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(drinks[mid]>x){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return left;
    }
}

在这里插入图片描述



第一个错误的版本


在这里插入图片描述

在这里插入图片描述

/* The isBadVersion API is defined in the parent class VersionControl.
      boolean isBadVersion(int version); */

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left=1,right=n;
        int mid=0;
        while(left<=right){
            mid=left+((right-left)>>1);
            if(isBadVersion(mid)){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return left;
    }
}

在这里插入图片描述



采购方案

在这里插入图片描述

在这里插入图片描述

class Solution {
    
    //先排序再二分
    public int fun(int[] nums,int target){
        Arrays.sort(nums);
        int ans=0;
        for(int i=0;i<nums.length-1;++i){
            if(nums[i]>=target)break;
            //二分找到比target-nums[i]大的最左位置
            int index=getIndex(nums,target-nums[i],i+1,nums.length-1);
            if(target-nums[i]>=nums[index]){
                ans+=(index-i);
            }else{
                ans+=(index-i-1);
            }
            ans%=1000000007;
        }
        return ans%1000000007;
    }
    public int getIndex(int[] nums,int x,int left,int right){
        if(left==right)return left;
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(nums[mid]>x){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return left;
    }
    public int purchasePlans(int[] nums, int target) {
        // return process(nums,0,2,target);
        // return DP(nums,target);
        return fun(nums,target);
    }
}

在这里插入图片描述



和为s的两个数字

在这里插入图片描述

class Solution {
    public int index(int[] nums,int x,int left,int right){
        int mid=0;
        while(left<right){
            mid=left+((right-left)>>1);
            if(nums[mid]==x)return mid;
            else if(nums[mid]<x){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;
    }
    public int[] twoSum(int[] nums, int target) {
        int[] ans=new int[2];
        for(int i=0;i<nums.length-1;++i){
            int cur=index(nums,target-nums[i],i+1,nums.length-1);
            if(target-nums[i]==nums[cur]){
                ans[0]=nums[i];
                ans[1]=target-nums[i];
                break;
            }
        }
        return ans;
    }
}

在这里插入图片描述



排序数组中两个数字之和

在这里插入图片描述

在这里插入图片描述

class Solution {
    public int index(int[] numbers,int x,int left,int right){
        int mid=0;
        while(left<right){
//        	System.out.println(left+" "+right);
        	mid=left+((right-left)>>1);
            if(numbers[mid]==x)return mid;
            else if(numbers[mid]<x){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;
    }
    public int[] twoSum(int[] numbers, int target) {

        int[] ans=new int[2];
        int cur=0;
        for(int i=0;i<numbers.length-1;++i){
        	
            cur=index(numbers,target-numbers[i],i+1,numbers.length-1);
            
            if(numbers[cur]==target-numbers[i]){
                ans[0]=i;
                ans[1]=cur;
                break;
            }
        }
        return ans;
    }
}

在这里插入图片描述



查找插入位置

在这里插入图片描述

在这里插入图片描述


class Solution {
    public int searchInsert(int[] nums, int target) {

        int left=0,right=nums.length-1;
        int mid=0;
        while(left<=right){
            mid=left+((right-left)>>1);
            if(nums[mid]==target)return mid;
            else if(nums[mid]<target){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;
    }
}

在这里插入图片描述



山峰数组的顶部

在这里插入图片描述

在这里插入图片描述

class Solution {

    //O(N)解法
    public int process1(int[] arr){
        for(int i=0;i<arr.length-1;++i){
            if(arr[i]>arr[i+1]){
                return i;
            }
        }
        return 0;
    }
    //O(longN)解法
    //二分查找
    public int process2(int[] arr){
        int left=0,right=arr.length-1;
        int mid=0;
        while(left<=right){
            mid=left+((right-left)>>1);
            if(mid==0){
                left=mid+1;
            }
            else if(mid==arr.length-1){
                right=mid-1;
            }
            else if(arr[mid]>arr[mid-1]&&arr[mid]>arr[mid+1]){
                return mid;
            }else if(arr[mid]>arr[mid-1]&&arr[mid]<arr[mid+1]){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return 0;
    }
    public int peakIndexInMountainArray(int[] arr) {
        // return process1(arr);
        return process2(arr);
    }
}

在这里插入图片描述



求平方根

在这里插入图片描述

class Solution {
    public int mySqrt(int x) {
        if(x==0||x==1)return x;
        long left=1,right=x/2;
        long mid=left+((right-left)>>1);
        while(left<=right){
            mid=left+((right-left)>>1);
            if(mid*mid==x){
                break;
            }
            else if(mid*mid<x){
                if((mid+1)*(mid+1)>x)break;
                left=mid+1;
            }
            else{
                right=mid-1;
            }
        }
        return (int)mid;
    }
}

在这里插入图片描述



最接近的二叉搜索树值


在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    
    public int closestValue(TreeNode root, double target) {
        TreeNode cur=root;
        int ans=0;
        double min=Integer.MAX_VALUE;
        while(cur!=null){
            if(min>=Math.abs(cur.val-target)){
                min=Math.abs(cur.val-target);
                ans=cur.val;
            }
            if(target<cur.val){
                cur=cur.left;
            }else{
                cur=cur.right;
            }
        }
        
        return ans;
    }
}

在这里插入图片描述

C++狂粉
关注
【C++】二分查找及例题
阿怪的博客
09-28 1182
二分查找 引例：A心里想一个1-1000之间的数，B来猜，可以问问题，A只能回答是或否。怎么猜才能问的问题次数最少? 顺序查找：是1吗?是2吗? …是999吗?平 均要问500次 二分查找：大于500吗?大于750吗?大于625吗? … 每次缩小猜 测范围到上次的一半，只需要10次 二分查找的内容必须是有序的。 例1：写一个函数BinarySeach，在包含size个元素的、从小到大排序的int数组a里查找元素p,如果找到，则返回元素下标，如果找不到，则返回-1。要求复杂度O(log(n))。 代
C语言二分查找题目练习
最新发布
weixin_46272660的博客
04-09 662
二分查找也称为对半查找，是一种在有序数组中查找特定元素的搜索算法。其核心思想是将数组不断对半分割，并比较中间值与目标值的大小来缩小搜索范围。如果中间值等于目标值，则查找成功；如果中间值小于目标值，则目标值在数组的右半部分；如果中间值大于目标值，则目标值在数组的左半部分。二分查找解题的前提：数组元素是有序且不重复的。因为一旦有重复元素，二分查找返回的元素下标可能不是唯一的。所以只有当题目满足上述条件后才可以考虑是否使用二分法。
二分查找相关题目
林竹清_清清清
07-11 869
一、注意： （1）有序数组，时间复杂度O(logn)  while(low （2）有序循环数组（有序数组左边任意长度移到右边，比如1 2 3 4 5的变形3 4 5 1 2就是有序循环数组。） （3）Mid=(left+right)/2是经典写法，但当left或right特别大时可能溢出，所以安全写法是mid=left+(right-left)/2; （4）二分查找不一定是有序数组的，只要
二分查找例题
weixin_41710285的博客
06-08 292
low = 0print(mid)breakelse:count = 1else:breakelse:break。
二分查找的python实现（及相关题目）（csdn）————程序.pdf
12-04
二分查找是一种高效的搜索算法，尤其适用于有序数据集。其基本原理是通过不断将待搜索的区间减半，来快速定位目标元素。...同时，熟悉这些相关题目有助于巩固对二分查找的理解，并能灵活应用到实际问题中。
二分查找的python实现（及相关题目）
Yzy_fulture的博客
11-24 1740
二分查找1. 二分查找相关知识1.1 算法介绍： 1. 二分查找相关知识 1.1 算法介绍： 二分查找算法（Binary Search Algorithm）：也叫做折半查找算法、对数查找算法。是一种在有序数组中查找某一特定元素的搜索算法。 注意， 有序数组中的一种搜索算法，有序数组中的一种搜索算法，有序数组中的一种搜索算法。当你看到有序数组时，就可以往二分查找这里想一想，看看能否运用。 基本思想：先确定带查找元素所在的区间范围，再逐步缩小范围，直到找到元素或找不到元素为止。 ...
简单的二分查找
errors_F的博客
02-21 769
例题一：第K个缺失的正整数 链接：https://leetcode-cn.com/problems/kth-missing-positive-number/ 题目描述： 给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。 请你找到这个数组里第 k 个缺失的正整数。 示例 1： 输入：arr = [2,3,4,7,11], k = 5 输出：9 解释：缺失的正整数包括 [1,5,6,8,9,10,12,13,…] 。第 5 个缺失的正整数为 9 。 示例 2： 输入：arr = [1,2,
使用PHP实现二分查找算法代码分享
01-20
第一种方法: 【二分查找要求】：1.必须采用顺序存储结构 2.必须按关键字大小有序排列。 【优缺点】折半查找法的优点是比较次数少，查找速度快，平均性能好;其缺点是要求待查表为有序表，且插入删除困难。因此，折半...
二分查找(力扣)
txwhmeng的博客
07-26 123
给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1 来源：力扣（LeetCod...
leetcode——二分查找系列题目（C++）
weixin_44226857的博客
07-24 556
题目列表69. x 的平方根744. 寻找比目标字母大的最小字母540. 有序数组中的单一元素278. 第一个错误的版本153. 寻找旋转排序数组中的最小值34. 在排序数组中查找元素的第一个和最后一个位置 69. x 的平方根 二分查找即可，其中mid的平方可能会超出int的类型，所以转成long long 在比较，由于left+1，可能会去除正确结果，最后在核实一下即可 class Solution { public: int mySqrt(int x) { int .
二分查找 常见题目
yn20000227的博客
07-21 196
二分查找 常见题目
二分搜索的题目
Ding_xiaofei的博客
09-17 460
二分搜索 针对有序的数组，主要是一些边界的问题 leetcode_35 题解 public class Leetcode_35 { public int searchInsert(int[] nums, int target) { int l = 0; int r = nums.length-1; while(l&amp;amp;lt;=r...
二分查找题目汇总
雪糕cool的博客
07-12 1896
二分查找题目汇总
Leetcode题解——算法思想之二分查找
dieshi8689的博客
06-12 311
1. 求开方 2. 大于给定元素的最小元素 3. 有序数组的 Single Element 4. 第一个错误的版本 5. 旋转数组的最小数字 6. 查找区间 正常实现 Input : [1,2,3,4,5] key : 3 return the index : 2 public int binarySearch(int[] nums, int key)...
二分查找及例题
lebowskii的博客
11-07 752
二分查找
二分查找算法实现与示例
在这个题目中，我们看到一个名为`SortedList`的类，它实现了二分查找功能。这个类的主要部分包括一个构造函数，用于初始化存储有序整数的数组`Elements`；一个析构函数，用于在对象不再使用时释放内存；以及`Binary...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值