六、二分搜索-算法总结

已于 2024-09-15 10:03:27 修改
阅读量587 收藏 19
点赞数 14
分类专栏： # Java算法 文章标签： 算法
于 2024-09-15 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44063529/article/details/142172477
版权

文章目录

六、二分搜索

6.1 简介

给一个有序数组和目标值，找第一次/最后一次/任何一次出现的索引，如果没有出现返回-1
模板四点要素

  • 1、初始化
  • 2、循环退出条件
  • 3、比较中点和目标值
  • 4、判断最后两个元素是否符合：A[mid] ==、<、> target
    时间复杂度O(logn)，使用场景一般是有序数组的查找

6.2 典型实例 – 二分查找

704. 二分查找
在这里插入图片描述

class Solution {
    // 二分搜索最常用模板
    public int search(int[] nums, int target) {
        // method1: 基于迭代
        // int left = 0, right = nums.length-1;
        // while (left<=right){
        //     int mid = (left+right)/2;
        //     if(target > nums[mid]){
        //         left = mid+1;
        //     }else if(target < nums[mid]){
        //         right = mid-1;
        //     }else{
        //         return mid;
        //     }
        // }
        // return -1;
        // method2: 基于递归
        return search(0, nums.length - 1, nums, target);
    }

    private int search(int left, int right, int[] nums, int target) {
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] > target) {
            return search(left, mid - 1, nums, target);
        } else {
            return search(mid + 1, right, nums, target);
        }

    }
}

6.2 模板

大部分二分查找类的题目都可以用这个模板，然后做一点特殊逻辑即可
另外二分查找还有一些其他模板如下图，大部分场景模板#3 都能解决问题，而且还能找第一次/最后一次出现的位置，应用更加广泛
在这里插入图片描述

所以用模板#3就对了，详细的对比可以这边文章介绍：二分搜索模板
如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用模板#1，代码更简洁常见题目

6.3 常见题目

6.3.1 搜索插入位置

35. 搜索插入位置
在这里插入图片描述

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

        // 对最后两个结果进行判断 (此时：left+1=right)
        // target逻辑上最终的落点：负无穷,left,right,正无穷
        if(nums[left] >= target){
            return left;
        }else if(nums[right] >= target){
            return right;
        }else{
            return right+1;
        }
    }
}

6.3.2 搜索二维矩阵

74. 搜索二维矩阵
在这里插入图片描述

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        // 先定位在哪一行
        int raw = 0;
        for(int i = 0;i<matrix.length;i++){
            if(target >= matrix[i][0] && target <= matrix[i][matrix[i].length-1]){
                if(target == matrix[i][0] || target == matrix[i][matrix[i].length-1]){
                    return true;
                }
                raw = i;
                break;
            }
        }

        // 在定位中搜索目标值
        int[] raws = matrix[raw];
        int left = 0, right = raws.length-1;
        while(left<=right){
            int mid = left + (right - left) / 2;
            if(raws[mid] == target){
                return true;
            }else if(raws[mid] > target){
                right = mid -1;
            }else{
                left = mid + 1;
            }
        }
        return false;
    }
}

6.3.3 寻找旋转排序中数组中的最小值

寻找旋转排序数组中的最小值
在这里插入图片描述

在这里插入图片描述

class Solution {
    public int findMin(int[] nums) {
        if(nums.length == 1){
            return nums[0];
        }
        int left = 0, right = nums.length - 1;
        while(left + 1 < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]){
                right = mid;
            }else{
                left = mid;
            }
        }
        return Math.min(nums[left], nums[right]);
    }
}

6.3.4 寻找旋转排序数组中的最小值 II

154. 寻找旋转排序数组中的最小值 II
在这里插入图片描述

在这里插入图片描述

// method1: 若最小值出现不止一次，此方法定位的最小值位置不能确定是否是原单调递增的最左侧的数据位置
class Solution {
    public int findMin(int[] nums) {
        if(nums.length == 1){
            return nums[0];
        }
        int left = 0, right = nums.length - 1;
        while(left + 1 < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]){
                right = mid;
            }else if(nums[mid] > nums[right]){
                left = mid;
            }else{
                right--;
            }
        }
        return Math.min(nums[left], nums[right]);
    }
}

// method2: 若最小值出现不止一次，此方法定位的最小值位置是原单调递增的最左侧的数据位置
class Solution {
    public int findMin(int[] nums) {
        if(nums.length == 1){
            return nums[0];
        }
        int left = 0, right = nums.length - 1;
        while(left + 1 < right){
            while(left<right && nums[left] == nums[left+1]){ // 去除左侧重复数字(仅保留一个)
                left++;
            }
            while(left<right && nums[right] == nums[right-1]){ // 去除右侧重复数字(仅保留一个)
                right--;
            }
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]){
                right = mid;
            }else if(nums[mid] > nums[right]){
                left = mid;
            }
        }
        return Math.min(nums[left], nums[right]);
    }
}

6.3.5 搜索旋转排序数组

33.搜索旋转排序数组
在这里插入图片描述

// method1: 基于两趟搜索
// 时间复杂度 O(logn)
class Solution {
    public int search(int[] nums, int target) {
        if(nums.length == 1){
            return nums[0]==target?0:-1;
        }
        // 找到最小值所在位置
        // 其左侧（若存在）是递增的
        // 其右侧（包括它自己）是递增的
        int left = 0, right = nums.length - 1;
        while(right - left > 1){
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]){
                right = mid;
            }else{
                left = mid;
            }
        }
        // 定位最小值的位置
        int minIndex = nums[left] < nums[right] ? left:right;
        // target 可能存在于右边
        if(target>=nums[minIndex] && target<=nums[nums.length-1]){
            return search(nums, minIndex, nums.length-1,target);
        }
        // target 可能存在于左边（注意：nums本身为递增数组）
        if(minIndex != 0 && (target>=nums[0] && target<=nums[minIndex-1])){
            return search(nums, 0, minIndex-1,target);
        }
        return -1;
    }
    private int search(int[] nums,int left, int right, int target){
        if(right < 0){
            return -1;
        }
        while(left+1<right){
            int mid = left + (right-left) / 2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                left = mid;
            }else{
                right = mid;
            }
        }
        if(nums[left] == target){
            return left;
        }else if(nums[right] == target){
            return right;
        }
        return -1;
    }
}

// method2: 基于一趟搜索
// 时间复杂度 O(logn)
class Solution {
    public int search(int[] nums, int target) {
        if(nums.length == 1){
            return nums[0]==target?0:-1;
        }
        int left = 0, right = nums.length - 1;
        while(right - left > 1){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return mid;
            }
            if(nums[mid] > nums[left]){ // 位于左边较大的单调区间
                if(target >= nums[left] && target < nums[mid]){
                    right = mid; // 位于闭区间 [left, mid]
                }else{ 
                // 位于开区间 [-无穷, left] or [mid, 当前区间的右边界] == [mid, right]
                // 注意[-无穷, left]就是其右侧的较小单调区间
                    left = mid;
                }
            }
            if(nums[mid] < nums[right]){ // 位于右边较小的单调区间
                if(target > nums[mid] && target <= nums[right]){
                    left = mid; // 位于闭区间 [mid, right]
                }else{ 
                // 位于开区间 [当前区间的左边界, mid] or [right, +无穷] == [left, mid]
                // 注意[right, +无穷]就是其左侧的较大单调区间
                    right = mid;
                }
            }
        }
        // 对最后的两个数据进行判断
        if(nums[left] == target){
            return left;
        }else if(nums[right] == target){
            return right;
        }
        return -1;
    }

}

6.3.6 搜索旋转排序数组 II

搜索旋转排序数组 II
在这里插入图片描述

// mthod1: 基于两趟搜索
// 时间复杂度：O(logn)
class Solution {
    public boolean search(int[] nums, int target) {
        // step 1: 定位最小值位置(需要定位原单调递增的最左侧的值的位置)
        int left = 0, right = nums.length - 1;
        while(right - left > 1){
            while(left < right && nums[left] == nums[left+1]){ // 去除左侧重复的数字
                left++;
            }
            while(left < right && nums[right] == nums[right-1]){ // 去除右侧重复的数字
                right--;
            }
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]){
                right = mid;
            }else{
                left = mid;
            }
        }
        int minIndex = (nums[left] <= nums[right] ? left:right);

        // step: 判断目标值位于哪个区间中查询
        if(target>=nums[minIndex] && target <= nums[nums.length - 1]){
            return search(nums, minIndex, nums.length - 1, target);
        }
        if(minIndex !=0 && target >= nums[0] && target <= nums[minIndex-1]){
            return search(nums, 0, minIndex - 1, target);
        }
        return false;
    }

    private boolean search(int[] nums, int left, int right, int target){
        while(right - left > 1){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return true;
            }else if(nums[mid] < target){
                left = mid;
            }else{
                right = mid;
            }
        }
        if(nums[left] == target || nums[right] == target){
            return true;
        }
        return false;
    }
}

// mthod2: 基于一趟搜索
// 时间复杂度：O(logn)
class Solution {
    public boolean search(int[] nums, int target) {
        if(nums.length == 1){
            return nums[0] == target;
        }

        int left = 0, right = nums.length - 1;
        while(right - left > 1){

            while(left<right && nums[left] == nums[left+1]){
                left++;
            }
            while(left<right && nums[right] == nums[right-1]){
                right--;
            }

            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return true;
            }

            // 当前mid位于左侧区间
            if(nums[mid] > nums[left]){
                if(target>=nums[left] && target < nums[mid]){
                    right = mid;
                }else{
                    left = mid;
                }
            }
            // 当前mid位于右侧区间
            if(nums[mid] < nums[right]){
                if(target > nums[mid] && target <= nums[right]){
                    left = mid;
                }else{
                    right = mid;
                }
            }
        }
        if(nums[left] == target || nums[right] == target){
            return true;
        }
        return false;

    }
}

总结

二分搜索四点要素（必背&理解）

  • 1、初始化：start=0、end=len-1
  • 2、循环退出条件：start + 1 < end
  • 3、 比较中间点和目标值：A[mid] ==、<、> target
  • 4、判断最后两个元素是否符合：A[start]、A[end] ? target
ModelBulider
关注
专栏目录
二分查找算法题个人总结
01-04
二分查找算法是一种高效的数据搜索方法，常用于已排序的数组或列表中。它通过不断缩小搜索范围，将目标元素定位到正确的位置。在本文中，我们将深入探讨二分查找的几种常见变体，以及如何根据不同的问题需求来选择...
数据结构与算法-二分搜索树
菜鸟小码的博客
07-31 1231
二分搜索树是一种特殊的二叉树，它具有独特的性质，使得在树中查找、插入和删除元素变得非常高效。本文将深入探讨二分搜索树的基本原理、实现步骤，并通过具体的案例代码详细说明二分搜索树的每一个细节。
二分搜索-算法分析
yangyangyiyang_的博客
09-13 337
所以，初始的中间位置是 \((0 + 7) / 2 = 3.5\)，向下取整后得到3，对应的元素是7。每次迭代中，中间位置的计算方式通常是取当前搜索范围的起始索引和结束索引的平均值，然后向下取整，以确保索引值是有效的整数。**例子**：如果数组是 \[1, 3, 5, 7, 9, 11, 13, 15\]，并且我们要查找的元素是7（数组中间的元素），那么只需要一次比较就能找到目标值。**时间复杂度**：\(O(\log n)\)，其中 \(n\) 是数组中的元素数量。
python二分查找算法_二分查找算法(Python)
weixin_39848998的博客
12-04 307
介绍二分查找也称折半查找(Binary Search)，它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。前提必须待查找的序列有序时间复杂度O(log2n)原理1)确定该期间的中间位置K2)将查找的值t与array[k]比较，若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。3)区域确定过程：若array[k]>t，由于数组...
2025届华子机考备战练习-二分搜索特训
weixin_41719116的博客
09-08 239
思路很简单，细节是魔鬼。几个最常用的二分查找场景：寻找一个数、寻找左侧边界、寻找右侧边界。
Python如何实现的二分查找算法
09-16
总结起来，Python实现的二分查找算法主要涉及以下几个关键点： 1. 初始化搜索范围：`low`和`high`分别表示数组的起始和结束下标。 2. 计算中间位置：`mid = (low + high) // 2`，确保向下取整。 3. 比较中间元素：...
PHP实现的二分查找算法实例分析
10-18
PHP中关于二分查找算法的学习可以参考相关的教程和总结，例如《PHP数据结构与算法教程》、《php程序设计算法总结》等资料，这些资料提供了算法的背景知识、应用示例以及PHP中实现的技巧和注意事项。此外，PHP中还有...
Python3实现二分查找算法（源代码）
04-30
二分查找算法是一种高效的搜索技术，主要用于在已排序的数组中查找特定的元素。与线性搜索相比，二分查找的时间复杂度更低，仅为 O(log n)，这使得它在处理大数据集时非常有用。下面将详细介绍二分查找算法的工作...
js实现的二分查找算法实例
10-22
二分查找算法是一种在有序数组中查找特定元素的高效算法。其基本思想是将数组分为两半，通过比较...二分查找由于其高效的搜索性能，在很多应用场景中被广泛应用，例如在数据密集型应用中，对大量数据的快速检索需求。
34. 在排序数组中查找元素的第一个和最后一个位置
weixin_61695887的博客
10-12 493
请你找出给定目标值在数组中的开始位置和结束位置。给你一个按照非递减顺序排列的整数数组。你必须设计并实现时间复杂度为。如果数组中不存在目标值。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 802
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 148
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 357
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【优选算法】（第四十二篇）
weixin_73861555的博客
10-15 778
输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log","cog"]输出：5。输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log"]输出：0。解释：⼀个最短转换序列是"hit"->"hot"->"dot"->"dog"->"cog",返回它的⻓度5。解释：endWord"cog"不在字典中，所以⽆法进⾏转换。
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 868
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
27.数据结构与算法-图的遍历（DFS,BFS）
q1312022158的博客
10-10 381
遍历定义与遍历实质 图的特点 图的常用遍历方法 深度优先搜索-DFS 邻接矩阵表示的无向图深度遍历实现 DFS算法效率分析 非连通图的遍历 广度优先搜索遍历-BFS 邻接表表示的无向图广度遍历实现 BFS算法效率分析 非连通图的广度遍历 DFS和BFS算法效率比较
水库抽样算法（大数据算法作业）
C_K_Y的博客
10-12 321
水库抽样技术归根到底就是在总体容量未知的情况下，仅通过单遍扫描数据集便能生成等概率抽样集合的一种均匀抽样技术。代码或许很简单，但是其中的数学知识以及思想方法是很值得学习的！
【优选算法】（第三十一篇）
weixin_73861555的博客
10-10 670
对于⼀个⼦串⽽⾔，如果它是回⽂串，并且⻓度⼤于2，那么将它⾸尾的两个字⺟去除之后，它仍然是个回⽂串。我们可以先找出前两个的最⻓公共前缀，然后拿这个最⻓公共前缀依次与后⾯的字符串⽐较，这样就可以找出所有字符串的最⻓公共前缀。题⽬要求多个字符串的公共前缀，我们可以逐位⽐较这些字符串，哪⼀位出现了不同，就在哪⼀位截⽌。输⼊：strs=["flower","flow","flight"]输⼊：strs=["dog","racecar","car"]给你⼀个字符串s，找到s中最⻓的回⽂⼦串。输⼊：s="babad"
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ModelBulider

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值