【Leetcode】有关于二分查找的一些题（更新于2021.7.11）

最新推荐文章于 2024-07-14 14:55:48 发布
最新推荐文章于 2024-07-14 14:55:48 发布
阅读量217 收藏
点赞数 1
分类专栏： leetcode 文章标签： 二分法 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41279172/article/details/115552052
版权

二分查找

1.T69 x 的平方根

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-06 13:53
 * @Description:
 */
public class T69 {

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

    public static void main(String[] args) {
        T69 t69 = new T69();
        System.out.println(t69.mySqrt(8));
    }
}

2.T744.寻找比目标字母大的最小字母

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-08 15:08
 * @Description:
 */
public class T744 {

    public char nextGreatestLetter(char[] letters, char target) {
        int l = 0, r = letters.length - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if(letters[mid] <= target)//可能会存在重复情况
                l = mid + 1;
            else
                r = mid - 1;
        }
        return letters[l % letters.length];
    }

    public static void main(String[] args) {
        T744 t744 = new T744();
        System.out.println(t744.nextGreatestLetter(new char[]{'c', 'f', 'g'}, 'c'));
    }
}

3.T278 第一个错误的版本

题目链接

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

4.T540 有序数组中的单一元素

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-08 19:49
 * @Description:
 */
public class T540 {

    public int singleNonDuplicate(int[] nums) {
        //每次二分都是将数组分为满足条件的和不满足条件的
        int l = 0, r = nums.length - 1;
        while (l < r) {
            int mid = l + (r - l) / 2;
            if(nums[mid] != nums[mid - 1] && nums[mid] != nums[mid + 1])
                return nums[mid];
            if(nums[mid] == nums[mid + 1]) {
                //是重复的中的前一个
                if((r - mid + 1) % 2 == 1)
                    l = mid + 2;
                else
                    r = mid - 1;
            } else if(nums[mid] == nums[mid - 1]){
                //是重复的中的后一个
                if((r - mid) % 2 == 0){
                    //右边为偶数个数
                    r = mid - 2;
                } else
                    l = mid + 1;
            }
        }
        return nums[l];
    }
}

5.T33 搜索旋转排序数组

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-07 15:18
 * @Description:
 */
public class T33 {

    /**
     * @Author Alone
     * @Description 二分查找 船新版本
     * @Date  2021/4/7 15:18
     * @Param [int[], int]
     * @return int
     **/
    public int search(int[] nums, int target) {
        //拿nums[mid]值与nums[l]比较，如果小于则mid~r为递增，反之则l~mid为递增
        int l = 0, r = nums.length - 1;
        while (l <= r){
            int mid = l + (r - l) / 2;
            if(target == nums[mid])
                return mid;
            if(nums[l] <= nums[mid]) {
                //left ~ mid有序
                if(target >= nums[l] && target < nums[mid])
                    r = mid - 1;
                else
                    l = mid + 1;
            } else{
                //mid ~ right有序
                if(target > nums[mid] && target <= nums[r])
                    l = mid + 1;
                else
                    r = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        T33 t33 = new T33();
        System.out.println(t33.search(new int[]{4,5,6,7,0,1,2}, 0));
    }
}

6.T81 搜索旋转排序数组 II

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-07 15:43
 * @Description:
 */
public class T81 {

    /**
     * @Author Alone
     * @Description
     * @Date  2021/4/7 15:43
     * @Param [int[], int]
     * @return boolean
     **/
    public boolean search(int[] nums, int target) {
        //二分的本质是两段性，并非单调性。只要一段满足某个性质，另外一段不满足某个性质，就可以用二分
        if(nums[0] == nums[nums.length - 1]){
            for (int num : nums) {
                if(target == num)
                    return true;
            }
            return false;
        }
        //拿nums[mid]值与nums[l]比较，如果小于则mid~r为递增，反之则l~mid为递增
        int l = 0, r = nums.length - 1;
        while (l <= r){
            int mid = l + (r - l) / 2;
            if(target == nums[mid])
                return true;
            if(nums[l] <= nums[mid]) {
                //left ~ mid有序
                if(target >= nums[l] && target < nums[mid])
                    r = mid - 1;
                else
                    l = mid + 1;
            } else{
                //mid ~ right有序
                if(target > nums[mid] && target <= nums[r])
                    l = mid + 1;
                else
                    r = mid - 1;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        T81 t81 = new T81();
        System.out.println(t81.search(new int[]{1, 0, 1, 1, 1}, 0));
    }
}

7.T153 寻找旋转排序数组中的最小值

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-08 13:38
 * @Description:
 */
public class T153 {

    /**
     * @Author Alone
     * @Description 二分查找
     * @Date  2021/4/8 14:32
     * @Param [int[]]
     * @return int
     **/
    public int findMin(int[] nums) {
        int l = 0, r = nums.length - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if(nums[mid] >= nums[l])
                l = mid;
            else
                r = mid - 1;
        }
        return r + 1 < nums.length ? nums[r + 1] : nums[0];
    }
}

8.T154 寻找旋转排序数组中的最小值 II

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-09 15:00
 * @Description:
 */
public class T154 {

    public int findMin(int[] nums) {
        int l = 0, r = nums.length - 1;
        while (r >= 0 && nums[r] == nums[0]) r--;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if(nums[mid] >= nums[l])
                l = mid;
            else
                r = mid - 1;
        }
        return r + 1 < nums.length ? nums[r + 1] : nums[0];
    }
}

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

题目链接

/**
 * @BelongsProject: study
 * @BelongsPackage: PACKAGE_NAME
 * @Author: Alone
 * @CreateTime: 2021-04-09 14:34
 * @Description:
 */
public class T34 {

    /**
     * @Author Alone
     * @Description 在排序数组中查找元素的第一个和最后一个位置
     * @Date  2021/4/9 14:56
     * @Param [int[], int]
     * @return int[]
     **/
    public int[] searchRange(int[] nums, int target) {
        //二分查找计算中位数有两种方式，一种在遇到等号时偏左，一种偏右
        int[] result = new int[2];
        int l = 0, r = nums.length - 1, mid = 0;
        while (l < r) {
            mid = l + r + 1 >> 1;//偏右
            if(nums[mid] > target)
                r = mid - 1;
            else
                l = mid;
        }
        result[1] = (l >= nums.length || nums[l] != target) ? -1 : l;
        l = 0; r = nums.length - 1;
        while (l < r) {
            mid = l + (r - l) / 2;//偏左
            if(nums[mid] < target)
                l = mid + 1;
            else
                r = mid;
        }
        result[0] = (l >= nums.length || nums[l] != target) ? -1 : l;
        return result;
    }

    public static void main(String[] args) {
        T34 t34 = new T34();
        System.out.println(t34.searchRange(new int[]{5,7,7,8,8,10}, 8));
    }
}

这题还有一种思路是把寻找target出现的最后位置转化为target+1应该插入的位置，这样只需要写一个二分查找函数。

10.T287 寻找重复数

题目链接

2021.4.14刷到一道可以用二分做的题，在此进行补充记录。

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，找出 这个重复的数 。

最开始想的过于简单，直接计算一下和进行比较。后面发现当重复数不止重复一次时会存在问题。

这道题可以使用二分法是由于抽屉原理——桌上有十个苹果，要把这十个苹果放到九个抽屉里，无论怎样放，我们会发现至少会有一个抽屉里面放不少于两个苹果。

基于抽屉原理可以对答案进行二分，每次统计数组中小于等于mid的数的个数cnt。如果cnt > mid，表示[l,mid]中存在重复数，即r = mid，反之则l = mid + 1。

/**
     * @Author Alone
     * @Description 二刷 二分法
     * @Date  2021/4/14 15:19
     * @Param [int[]]
     * @return int
     **/
    public int findDuplicate(int[] nums) {
        int l = 1, r = nums.length - 1;
        while (l < r) {
            int mid = l + (r - l) / 2;//注意此处是向下取整
            int cnt = 0;
            //统计小于等于mid的数的个数
            for (int num : nums) {
                if(num <= mid)
                    cnt ++;
            }
            if(cnt > mid)
                r = mid;
            else
                l = mid + 1;
        }
        return l;
    }

11.T274 H指数

题目链接

2021.7.11补充当日的每日一题。

题目的要求是**总共有 h 篇论文分别被引用了至少 h 次。且其余的 N - h 篇论文每篇被引用次数不超过 h 次。**理解这句话的时候有点绕。

思路很简单，首先给数组按从大到小排个序。接着对数组下标进行二分，数组根据下标形成二段性：对于中间值mid，如果mid满足题意，则小于mid的值也满足题意；如果mid不满足题意，那么大于mid的值也不满足题意。二分的判断条件是nums[mid] >= mid + 1。

public int hIndex(int[] citations) {
        Integer[] nums = new Integer[citations.length];
        for (int i = 0; i < citations.length; i++) {
            nums[i] = citations[i];
        }
        Arrays.sort(nums, (o1, o2) -> o2 - o1);
        int l = 0, r = citations.length - 1, ans = 0;
        while (l <= r) {
            int mid = (l + r + 1) / 2;
            if(nums[mid] >= mid + 1) {
                ans = l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return ans;
    }

总结

二分查找中有两种计算mid的方式:

  1. mid = l + (r - l) / 2;
  2. mid = l + r + 1 >> 1;

这两种方式在遇到数组长度为偶数时计算出来的结果不一样，第一种计算方式结果为左边的值（向下取整），第二种结果为右边的值（向上取整）。

二分法的本质是两段性，只要一段满足某个性质，另一段不满足就可以用二分法。

在81题和154题中，因为数组出现了重复元素，可能会导致分开的两段中均有元素满足性质，此时会退化为遍历查找。

while(left <= right) 在循环体内部直接查找元素，而 while(left < right) 在循环体内部一直在排除元素。

参考资料

1.CS-Notes
2.宫水三叶的题解
3.liweiwei1419的287题题解
4.274题题解

wannatolive
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
查成绩_二分查找
hipoole的博客
11-17 1114
【问题描述】 中考成绩出来了，许多考生想知道自己成绩排名情况，于是考试委员会找到了你，让你帮助完成一个成绩查找程序，考生只要输入成绩，即可知道其排名及同名次的人有多少。 【输入格式】 第一行一个数N（N<=10000)； 第二行一个数K； 第三行开始N个以空格隔开的从大到小排列的所有学生中考成绩。接着K个待查找的考生成绩。 【输出格式】 K行，每行为一个待查找的考生的名次、同名次的人数、比考...
LeetCode高频算法面试题,含解题思路及代码实现
02-17
3. **搜索算法**：二分查找、深度优先搜索（DFS）、广度优先搜索（BFS）等是常见的搜索技术。在解决LeetCode的题目时，理解它们的工作原理并能灵活应用是提高解题效率的关键。 4. **动态规划**：动态规划是一种通过...
LeetCode算法练习--二分查找例题
不停下脚步
07-08 149
算法练习
二分查找
莫逸雪的博客
12-30 153
题目 {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000. 代码 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int[] arr={1,8,10,89...
寻找第二问题
weixin_30472035的博客
05-16 129
2019-05-16 20:37:06 1.问题描述：在实际问题中，通常会遇到许多第二的问题。比如：第二名，第二大和第二小等。在已知的n个数据中找出其中第二小的数据。2.根据问题描述，利用数组a[]存储已知数据，定义两个变量，min1和min2，分别用来存储数据中的第一小值和第二小值，对已知数字进行比较之后，便可从中选出第二小的数据，输出即可。此算法的时间复杂度为O(n).3.算...
LintCode刷题笔记
MacKendy的博客
07-16 1099
1. DFS 1.1 Palindrome Partitioning 题目跳转：https://www.lintcode.com/problem/palindrome-partitioning/description class Solution: """ @param: s: A string @return: A list of lists of string """ def partition(self, s): # write your c
LeetCode 2064. 分配给商店的最多商品的最小值（二分查找）
Michael是个半路程序员
11-07 321
文章目录1. 题目2. 解题 1. 题目 给你一个整数 n ，表示有 n 间零售商店。 总共有 m 种产品，每种产品的数目用一个下标从 0 开始的整数数组 quantities 表示，其中 quantities[i] 表示第 i 种商品的数目。 你需要将 所有商品 分配到零售商店，并遵守这些规则： 一间商店 至多 只能有 一种商品 ，但一间商店拥有的商品数目可以为 任意 件。 分配后，每间商店都会被分配一定数目的商品（可能为 0 件）。用 x 表示所有商店中分配商品数目的最大值，你希望 x 越小越好。也就
leetcode每日一题2021.7.14【1818. 绝对差值和】
GarethYoung的博客
07-17 117
1846. 减小和重新排列数组后的最大元素一、题目描述1.题目内容2.题目示例示例1示例2示例33.提示二、思路思路思路2三、数据结构资料四、代码代码1代码2五、复杂度分析 一、题目描述 1.题目内容 给你两个正整数数组 nums1 和 nums2 ，数组的长度都是 n 。 数组 nums1 和 nums2 的绝对差值和定义为所有 |nums1[i] - nums2[i]|（0 <= i < n）的总和（下标从 0 开始）。 你可以选用 nums1 中的任意一个元素来替换 nums1 中的至多
Leetcode2021
03-17
3. **LeetCode问题分类**：LeetCode的问题涵盖了许多主题，包括数组、字符串、数学、双指针、回溯、动态规划、贪心、二分查找等。每类问题都有特定的解决思路和常用算法。 4. **Python效率优化**：在处理大规模数据...
leetcode2021
02-09
4. **算法**：包括排序（如冒泡排序、快速排序、归并排序）、查找（如二分查找）、动态规划、贪心算法、回溯法、分治策略等。LeetCode的题目设计往往旨在测试和提升这些算法的应用能力。 5. **Java在LeetCode中的...
leetcode卡-leetcode_maychallenge:网站链接：https://leetcode.com/explore/featu
07-06
1. **排序与搜索**：快速排序、归并排序、二分查找等基础算法的实现和优化。 2. **链表操作**：创建、插入、删除链表节点，以及链表的反转、合并等。 3. **树结构**：二叉树的遍历（前序、中序、后序）、平衡二叉树...
leetcode--恢复二叉搜索树
liulanba的博客
07-09 477
给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树。示例 1：输入：root = [1,3,null,null,2]输出：[3,1,null,null,2]解释：3 不能是 1 的左孩子，因为 3 > 1。交换 1 和 3 使二叉搜索树有效。示例 2：输入：root = [3,1,4,null,null,2]输出：[2,1,4,null,null,3]解释：2 不能在 3 的右子树中，因为 2 < 3。
力扣224.基本计算器
Pisasama的博客
07-14 133
【代码】力扣224.基本计算器。
leetcode--从中序与后序遍历序列构造二叉树
liulanba的博客
07-09 641
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。
leetcode--验证二叉搜索树
liulanba的博客
07-09 675
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
Leetcode【最长回文子串】
最新发布
wudi6688的博客
07-14 102
"aba" 同样是符合题意的答案。
力扣104题：二叉树最大深度
m0_56332819的博客
07-10 197
二叉树最大深度，C语言
leetcode704.二分查找
欢迎来到我的博客~
07-12 263
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。输入: nums = [-1,0,3,5,9,12], target = 9。输入: nums = [-1,0,3,5,9,12], target = 2。解释: 9 出现在 nums 中并且下标为 4。解释: 2 不存在 nums 中因此返回 -1。
算法题总结 2741
08-08
在本总结中，涉及到多个LeetCode题目，如查找插入位置、旋转数组中的数字等，它们都是二分查找的不同变种，涉及查找、范围查找、重复元素查找等场景。 2. 数组操作： - 包括查找特定条件的元素，如缺失的数字、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值