day75【代码随想录】二分查找专题

最新推荐文章于 2024-07-21 08:37:44 发布
最新推荐文章于 2024-07-21 08:37:44 发布
阅读量105 收藏
点赞数
文章标签： leetcode 算法 排序算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42338744/article/details/129851415
版权

文章目录

前言

1、寻找旋转排序数组中的最小值
2、寻找旋转排序数组中的最小值 II
3、搜索旋转排序数组
4、搜索旋转排序数组 II
5、搜索旋转数组
6、在排序数组中查找元素的第一个和最后一个位置

一、寻找旋转排序数组中的最小值（力扣154）

在这里插入图片描述
在这里插入图片描述
分析：
参考
大佬题解
关键部分：
在这里插入图片描述

之前总觉得二分必须是递增序列才能用 固化思维 左<中<右，跳出这个固定思维圈，更好理解

class Solution {
public int findMin(int[] nums) {
        //数组元素最小值
        int left =0;
        int right =nums.length-1;

        int mid;
        int res = 0;
        while(left<=right){
            mid = left +(right-left)/2;
            if(nums[mid]<nums[right]){
                right=mid;
            }else {
                res = left;
                left=mid+1;
            }
        }
        return nums[res];
    }
}

二、寻找旋转排序数组中的最小值 II（154）

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

尽可能减少整个操作步骤

class Solution {
    public int findMin(int[] nums) {
        int left = 0;
        int right = nums.length-1;
        int mid;
        int res=0;
        while(left<=right){
            mid = left+(right-left)/2;
            if(nums[mid]<nums[right]){
                //缩小右边界
                right = mid;
            }else if(nums[mid]>nums[right]){
                res = left;
                left = mid+1;
            }else if(nums[mid]==nums[right]){
                right--;
            }
        }
        return nums[left];
    }
}

三、搜索旋转排序数组（力扣33）

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

分析：
根据“寻找旋转排序数组中的最小值”找到最小值的下标位置，然后分为不同的情况划分区间进行二分查找

class Solution {
    public int search(int[] nums, int target) {
        //先找到最小值所对应的下标
        int left = 0;
        int right = nums.length-1;
        int mid=0 ;
        while(left<=right){
            mid = left+(right-left)/2;
            if(nums[mid]<nums[right]){
                right = mid;
            }else{
                left= mid+1;
            }
        }
        //mid就是最小值的下标 判断[mid,nums.length-1] 里是否有目标值
        if(nums[nums.length-1]<target && mid ==0){
            return -1;
        }else if(nums[nums.length-1]>=target ){
            return findByErFen(nums,mid,nums.length-1,target);
        }else if(mid!=0 && nums[nums.length-1]<target){
            //[0,mid-1];
            return findByErFen(nums,0,mid-1,target);
        }
        return -1;
    }
    public int findByErFen(int[] nums,int left,int right,int target){
        int l=left;
        int r=right;
        int mid;
        int ans =-1 ;
        while(l<=r){
            mid = l+(r-l)/2;
            if(nums[mid]>target){
                r=mid-1;
            }else if(nums[mid]<target){
                l=mid+1;
            }else{
                ans = mid;
                return ans;
            }
        }
        return ans;
    }
}

四、搜索旋转排序数组 II（力扣81）

在这里插入图片描述
在这里插入图片描述
分析：
和33类似，但是需要注意的是，会有重复值的情况出现，因此需要对数据进行一些预处理

        while (left <= right && nums[0] == nums[right]) {
            right--;
        }
        if(right==-1) return nums[0]==target?true:false;
        rightBorder = nums[right];
        index=right;

class Solution {
    public boolean search(int[] nums, int target) {
        //可能会有相同值出现
        //和1比较类似 但是有重复值的情况
        int left = 0;
        int right = nums.length-1;
        int mid=0;
        int res =0;

        int rightBorder=Integer.MIN_VALUE;
        int index = -1;
        if(nums.length==1){
            return nums[0]==target?true:false;
        }
        // 恢复二段性
        while (left <= right && nums[0] == nums[right]) {
            right--;
        }
        if(right==-1) return nums[0]==target?true:false;
        rightBorder = nums[right];
        index=right;
        while(left<=right){
            mid = left+ (right-left)/2;
            if(nums[mid]<nums[right]){
                right=mid;
            }else if(nums[mid]>nums[right]){
                left = mid+1;
            }else if(nums[mid]==nums[right]){
                right--;
            }
        }
        //mid 就是此时最小值所在位置的下标
        //进行二分查找target值
        if(mid==0 && target>rightBorder){
            return false;
        }else if(target<=rightBorder){
            return ErFen(nums,mid,index,target)==-1?false:true;
        }else if(mid!=0 &&target>rightBorder){
            return ErFen(nums,0,mid-1,target)==-1?false:true;
        }
        return false;
    }
    public int ErFen(int[] nums,int left,int right,int target){
        int l=left;
        int r = right;
        int mid;
        int ans = -1;
        while(l<=r){
            mid = l+(r-l)/2;
            if(nums[mid]>target){
                r=mid-1;
            }else if(nums[mid]<target){
                l=mid+1;
            }else{
               ans = mid;
               return ans;
            }
        }
        return ans;
    }
}

五、搜索旋转数组（面试题 10.03.）

在这里插入图片描述
分析：
上面的几道题相比，注释里给出了几个重点改变
重点一：当left符合时直接返回, 因为找的是最小的索引

        while (left <= right && nums[0] == nums[right]) {
            right--;
        }
        if(right==-1) return nums[0]==target?0:-1;

重点二：当中间值等于目标值，将右边界移到中间，因为左边可能还有相等的值

	while(l<=r){
            mid = l+(r-l)/2;
            if(nums[mid]>=target){
                if(nums[mid]==target){
                    ans = mid;
                }
                r =mid-1;
            }else if(nums[mid]<target){
                l=mid+1;
            }
        }

class Solution {
public int search(int[] nums, int target) {
        //可能会有相同值出现
        //和1比较类似 但是有重复值的情况
        int left = 0;
        int right = nums.length-1;
        int mid=0;
        int res =0;

        int rightBorder=Integer.MIN_VALUE;
        int index = -1;
        if(nums.length==1){
            return nums[0]==target?0:-1;
        }
                if(nums[0]==target) return 0;
        // 恢复二段性
        while (left <= right && nums[0] == nums[right]) {
            right--;
        }
        if(right==-1) return nums[0]==target?0:-1;
        rightBorder = nums[right];
        index=right;
        while(left<=right){
            mid = left+ (right-left)/2;
            if(nums[mid]<nums[right]){
                right=mid;
            }else if(nums[mid]>nums[right]){
                left = mid+1;
            }else if(nums[mid]==nums[right]){
                right--;
            }
        }
        if(nums[mid] ==target) return mid;
        //mid 就是此时最小值所在位置的下标
        //进行二分查找target值
        if(mid==0 && target>rightBorder){
            return -1;
        }else if(target<=rightBorder){
            return ErFen(nums,mid,index,target)==-1?-1:ErFen(nums,mid,index,target);
        }else if(mid!=0 &&target>rightBorder){
            return ErFen(nums,0,mid-1,target)==-1?-1:ErFen(nums,0,mid-1,target);
        }
        return -1;
    }
    public int ErFen(int[] nums,int left,int right,int target){
        int l=left;
        int r = right;
        int mid;
        int ans = -1;
        while(l<=r){
            mid = l+(r-l)/2;
            if(nums[mid]>=target){
                if(nums[mid]==target){
                    ans = mid;
                }
                r =mid-1;
            }else if(nums[mid]<target){
                l=mid+1;
            }
        }
        return ans;
    }
}

六、在排序数组中查找元素的第一个和最后一个位置（力扣34）

在这里插入图片描述

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[2];
        int leftBorder = searchLeftBorder(nums,target);
        int rightBorder = searchRightBorder(nums,target);
        if(rightBorder==-2 || leftBorder==-2 ){
            res[0]=-1;
            res[1]=-1;
            return res;
        }
        if(rightBorder-leftBorder>1){
            res[0]=leftBorder+1;
            res[1]=rightBorder-1;
        }else{
            res[0]=-1;
            res[1]=-1;
        }
        return res;
    }

    public int searchLeftBorder(int[] nums,int target){
        int left = 0;
        int right = nums.length-1;
        int res =-2;
        int mid;
        while(left<=right){
            mid = left+(right-left)/2;
            if(nums[mid]>=target){

                right = mid-1;
                res = right;
            }else{
                left = mid+1;
            }
        }
        return res;
    }

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

                left = mid+1;
                res = left;
            }
        }
        return res;
    }
}
Bwy_1004
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录刷题打卡day02
04-18
代码随想录刷题打卡day02
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
代码随想录day1-二分查找
m0_45172994的博客
02-20 171
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。关于这种二分查找的题目，本质上都是可以用暴力方法求解的，就是从头到尾直接遍历就行了。但是随着数据量的增大，暴力算法往往会面临超时的情况，所以需要使用更高效的查找方法。就是一种高效的查找算法。二分查找的难点以及容易混淆的地方主要是两个点，即循环体内部的条件，到底是呢还是呢，以及边界的改变条件是left = mid还是呢？
【代码随想录day1】二分查找专题
little_spice的博客
07-04 112
总体有两种方法去写二分查找，差异还挺大的，主要是边界的判断比较麻烦。 这里需要注意的是while left
二分查找 - 代码随想录 day1
qq_51762665的博客
03-27 78
开始做跟着代码随想录上的顺序做题，今天看的是二分法。二分法可以分为左闭右闭和左闭右开两种，左开右闭不常见，所以不做讨论。不一样的地方在于while循环结束的条件，以及循环内的具体内容。
代码随想录leetcode刷题Day01-二分查找
peach2580的博客
12-07 264
代码随想录leetcode刷题Day01-二分查找
day1【代码随想录】二分查找
qq_42338744的博客
11-20 81
二分查找
代码随想录Day1.1--二分查找
weixin_52895914的博客
09-06 52
因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件，代码如下。有很多错误（用的是左闭右开区间），不过没有考虑目标值在数组中找不到，返回-1的情况。改进一：A出来了，要考虑分区的不变量，我用的是左闭右闭区间[start, end]改进二：用下左闭右开区间[left, right)2 不存在nums中，因此返回 -1。，如果目标值存在返回下标，否则返回。9 出现在nums中并且下标为4。个元素有序的（升序）整型数组。
代码随想录学习-Day2(二分查找)
wusheng1998的博客
05-31 117
二分查找
代码随想录算法练习Day1:二分查找
2201_75378283的博客
04-02 1114
求中间位置的写法相比，可以避免在大数相加时可能导致的溢出问题，同时也更为高效。：二分法要求在查找的数据结构中元素按照某种顺序有序排列，通常是升序排列。：二分法适用于在有序数组或列表中查找目标元素是否存在，或者查找目标元素的位置。：二分法要求能够通过索引或指针以O(1)的时间复杂度访问数组或列表的任意位置。二分法（Binary Search）是一种在有序数组或列表中查找目标元素的算法。2.在写范围的时候，是根据是否包含数组的边界元素来确定的。示例1（左闭右闭写法）：​​​​​​​。表示当前搜索范围的长度，
代码随想录day1 二分查找 & 移除元素
lstarr的博客
05-21 173
解法一，双向指针：l和r分别从左右两端逼近中间；解法二：快慢指针，快指针遍历数组，慢指针指向不等于val的数组的后一个元素。解法二更简洁清晰，解法一的条件判断容易出错。1.2 开闭区间与循环不变量：一开始没有仔细思考开闭区间，直接将middle赋值给left或right，导致超时，通过添加r7~r12解决。1.1 为了防止数值溢出，将r14改为mid = l + (r - l) // 2。注意python的整除是//。空间复杂度O(n)，时间复杂度O(n)，事实上不符合题目“原地更改nums数组”的要求。
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
春节7天练丨Day3：排序和二分查找1
08-03
2. **模糊二分查找**：查找大于等于给定值的第一个元素，或小于等于给定值的最后一个元素。 除了这些基础算法，还有其他变种和优化，如在特定场景下结合不同排序算法，以提高效率，例如C标准库中的快速排序在小规模...
三角形构成及next day整体代码
12-30
在编程领域，三角形构成和"Next Day"问题都是常见的算法题目，主要涉及基础的数据结构、逻辑推理和日期处理。让我们分别深入探讨这两个知识点。 首先，我们关注的是“三角形构成”问题。这个问题通常出现在计算机...
stack(leetcode练习题)
2301_81692739的博客
07-19 381
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 324
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
最新发布
it_fly的专栏
07-21 147
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 293
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
代码执行漏洞审计：0DAY挖掘与实战技巧
"0DAY挖掘巧思-代码执行之漏洞审计-漏洞银行大咖面对面35-水清云影"是一场关于信息安全领域的技术直播讲座，由知名专家水清云影主讲。该讲座深入探讨了代码执行漏洞审计的重要性和实践技巧。讲座内容主要包括以下几...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值