二分法之旋转有序数组

最新推荐文章于 2023-09-03 18:08:01 发布
最新推荐文章于 2023-09-03 18:08:01 发布
阅读量1.8k 收藏
点赞数 1
分类专栏： Coding
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/racesu/article/details/112064254
版权

《二分法之旋转有序数组》

   二分查找实际上就是根据有序得条件进行边界收缩从而到 O(logn) 复杂度的搜索算法。二分法说简单也并不简单，Knuth 大佬（KMP 算法发明者）说过：Although the basic idea of binary search is comparatively straightforward,the details can be surprisingly tricky…，思路很简单，但是细节是魔鬼。所以对于旋转数组搜索问题更能够体现你对二分法的魔鬼细节了解多少。本文给出二分法的三种模板，寻中，寻左，寻右，以及对应LeetCode上五道题目的解法。本文给出的解法统一了：l <= r，先判断左区间是否为升序。

Key Words：二分法、旋转数组


Beijing, 2021.01

作者：RaySue

Agile Pioneer  

文章目录

标准二分法的三种形式

在有序数组中查找一个特定元素 target 的过程如下：

  • 若 target == nums[mid]，直接返回

  • 若 target < nums[mid]，则 target 位于左侧区间 [left,mid) 中。令 right = mid - 1，在左侧区间查找

  • 若 target > nums[mid]，则 target 位于右侧区间 (mid,right] 中。令 left = mid + 1，在右侧区间查找

  如果寻找的有序数组中有重复元素，可能有多个 target ，那么二分法应该取哪个值呢？通过对二分法的简单调整就可以实现这个功能，下面的代码为了方便理解，所以在寻左和寻右的时候就没有简写，实际用的时候可以将其中的两个分支合并即可。

C++ 代码模板

寻中

搜索所有target的中间元素位置

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

寻左

寻找所有target位于最左边的元素位置，注意要判断结果的左边界是否右溢出

int l = 0, r = nums.size() - 1, mid;
while(l <= r)
{
    mid = l + (r - l >> 1);
    if (nums[mid] < target) 
    {
    	l = mid + 1;
    } else if (nums[mid] > target)
    {
        r = mid - 1;
    } else {
        r = mid - 1;
    }
}
if (l >= nums.size() || nums[l] != target)
    return -1;

寻右

寻找所有target位于最右边的元素位置，注意要判断结果的右边界是否左溢出

int l = 0, r = nums.size() - 1, mid;
while(l <= r)
{
    mid = l + (r - l >> 1);
    if (nums[mid] < target) 
    {
    	l = mid + 1;
    } else if (nums[mid] > target)
    {
        r = mid - 1;
    } else {
        l = mid + 1;
    }
}
if (r < 0 || nums[r] != target)
    return -1;

旋转排序数组

   前面回顾了二分法一般情况的模板，我们的主角旋转排序数组登场了，这里提到的旋转排序数组就是对一个排序数组，进行了一次旋转即在某个位置进行了断开，然后把后部分放到前面，如下：

  • 旋转前：[1,2,3,4,5,6]

  • 旋转后：[4,5,1,2,3,4]

  • 标准的排序数组使用二分法搜索target示意图，绿色是左边界，红色是右边界，橙色是mid，星星是 target：

  • 旋转排序数组使用二分法搜索target示意图，左右两部分都是升序的，且左半部分大于右半部分：

旋转排序数组二分查找有四种:

  • 搜索特定值

    • 不包含重复元素的旋转排序数组
    • 包含重复元素的旋转排序数组

  • 搜索最小值

    • 不包含重复元素的旋转排序数组
    • 包含重复元素的旋转排序数组

旋转排序数组二分搜索 target

旋转排序数组二分搜索 target 的大致思路：

  • 若 target == nums[mid]，直接返回

  • 若 nums[left] <= nums[mid]，说明左侧区间 [left,mid]「连续递增」。此时：若 nums[left] <= target < nums[mid]，说明 target 位于左侧。令 right = mid-1，在左侧区间查找，否则，令 left = mid+1，在右侧区间查找

  • 否则，说明右侧区间 [mid,right]「连续递增」。此时：若 nums[mid] < target <= nums[right]，说明 target 位于右侧区间。令 left = mid+1，在右侧区间查找，否则，令 right = mid-1，在左侧区间查找

注意：区间收缩时不包含 mid，也就是说，实际收缩后的区间是 [left,mid) 或者 (mid,right]，因为mid在最初已经判断过了，每次你更新左右边界是否用 mid 加减 1的时候只需考虑一下 mid 是否被判断过，不要漏掉情况。

  • 不包含重复元素的旋转排序数组 搜索特定值
int search(vector<int> &nums, int target)
{
    int l = 0, r = nums.size() - 1, mid;
    while(l <= r)
    {
        mid = l + (r - l >> 1);
        if (nums[mid] == target) return mid;
        else if (nums[l] <= nums[mid])
        {
        	// 这里一定是 <= 否则就会漏掉情况
            if (nums[l] <= target && target < nums[mid])
            {
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        } 
        else
        {
        	//                    这里也一定是 <= 否则漏情况
            if (nums[mid] < target && target <= nums[r])
            {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
    }
    return -1;
}
  • 包含重复元素的旋转排序数组 搜索特定值

   对于包含重复的情况，我们就不能考虑[left,mid] 这个区间了，因为当 nums[left] == nums[mid] 的时候，我们是不知道要收缩左边界还是右边界的，这时候就退化为了线性查找，这在有重复元素nums[left] <= nums[mid] 拆开为 nums[left] < nums[mid] 即 nums[left] == nums[mid] 分开处理就行了。

bool search(vector<int> &nums, int target)
{
    int l = 0, r = nums.size() - 1, mid;
    while(l <= r)
    {
        mid = l + (r - l >> 1);
        if (nums[mid] == target) return true;
        else if (nums[l] < nums[mid])
        {
            if (nums[l] <= target && target < nums[mid])
            {
                r = mid - 1;    
            } else {
                l = mid + 1;
            }
        } else if (nums[l] > nums[mid])
        {
            if (nums[mid] < target && target <= nums[r])
            {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        } else 
        {
            // 这里提供线性查找的三种方式
            // 方式一
            nums[l] == nums[mid] ? l++: r--;
            // 方式二 判断 [l,mid] 区间
            //for (int i = l; i <= mid; ++i)
            //{
            //    if (nums[i] == target) return true;
            //}
            //l = mid + 1;
            // 方式三 判断 [mid,r] 区间
            //for (int i = mid; i <= r; ++i)
            //{
            //    if (nums[i] == target) return true;
            //}
            //r = mid - 1;
            // 方式四 直接判断 [l, r] 区间
        }
    }
    return false;
}

旋转排序数组 搜索最小值

  • 不包含重复元素的旋转排序数组 搜索最小值

旋转排序数组二分搜索 最小值 的大致思路：

  • 如果 nums[l] <= nums[r]，说明nums的[l, r]区间是单调递增的，返回nums[l]即可，考虑如果给定的nums压根就没旋转，那么结果肯定是对的。

  • 如果 nums[l] <= nums[mid]，说明nums的[l, r]区间是单调递增的，所以最小值肯定在 mid 右边，而且mid必然不是最小值，所以 l = mid + 1;

  • 如果 nums[l] > nums[mid]，说明 mid 在右半部分，即[mid, r]区间是单调递增的，所以最小值肯定在 mid 或 mid 左边，注意，此时 mid 可能就是最小值，所以 r = mid;

int findMin(vector<int> &nums)
{
    int l = 0, r = nums.size() - 1, mid;
    while(l <= r)
    {
        mid = l + (r - l >> 1);
        if (nums[l] <= nums[r]) return nums[l];
        else if (nums[l] <= nums[mid])
        {
            l = mid + 1;
        } else {
            r = mid;
        }
    }
    return -1;
}
  • 包含重复元素的旋转排序数组 搜索最小值

   对于包含重复的情况，我们就无法通过nums[l] <= nums[r]就认为nums[l]就是最小值， 举个例子[2,2,1,2,2,2]，显然此时的 nums[l] 就不是最小值。我的做法是在各个分支都计算更新一下最小值，比较好理解。

int findMin(vector<int> &nums)
{
    if (nums.empty()) return -1;
    if (nums.size() == 1) return nums.back();
    int minVal = nums[0];
    int l = 0, r = nums.size() - 1, mid;
    while (l <= r)
    {
        mid = l + (r - l >> 1);
        if (nums[l] < nums[mid])
        {
            minVal = min(minVal, nums[l]);
            l = mid + 1;
        } else if (nums[l] > nums[mid])
        {
            minVal = min(minVal, nums[mid]);
            r = mid - 1;
        } else
        {
            minVal = min(minVal, nums[mid]);
            nums[l] == nums[mid]? l++ : r--;
        }
    }
    return minVal;
}

参考

[1] https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/yi-wen-jie-jue-4-dao-sou-suo-xuan-zhuan-pai-xu-s-2/

[2] https://labuladong.gitbook.io/algo/di-ling-zhang-bi-du-xi-lie/er-fen-cha-zhao-xiang-jie

PS: 读完本文你可以立马去LeetCode解决一下五个问题：

  1. 33.搜索旋转排序数组
  2. 81.搜索旋转排序数组II
  3. 153.寻找旋转排序数组中的最小值
  4. 153.寻找旋转排序数组中的最小值II
  5. 剑指 Offer 11.旋转数组的最小数字
Mr.RottenPeach
关注
专栏目录
leetcode:33.搜索旋转排序数组
uncle_ll的博客
08-14 622
在传递给函数之前，nums 在预先未知的某个下标 k（0
前端面试官：请使用二分法搜索旋转数组
个人前端记录
05-27 575
???? 本文首发于：https://www.shaotianyu.com/，目标是把自己知道的东西讲明白 1 基本的二分法是什么样子的 二分法的使用场景，其实比较受限，最明显的特点是： 绝大情况，查找目标具有单调性质（单调递增、单调递减） 有上下边界，并且最好能够通过index下标访问元素 1.1 从头开始，基本的二分法使用 我们从一个最简单的单调递增数组开始说起，问题如下： 在 [1, 2, 3, 4, 5, 6, 7, 8, 9] 中找到 4，若存在则返回下标，不存在返回-1，要求算法复杂度O(
旋转排序数组
HackingGate的博客
06-21 1617
Leetcode上有四道旋转排序数组的题目，都是使用二分法。使用二分法的关键点是想到这样一个事实：每次二分，左半边和右半边肯定有一边是能确定有序的。那么，无论是找最小值，还是搜索某个数，先在确定有序的那边找，没找到的话再对不确定有序的那边继续二分。 首先要确定，nums[mid] 究竟和 nums[left] 以及 nums[right] 中的哪一个比较，可以把目标值套在一个可确定的区间里。 1. 找最小值问题 如果是找最小值，那么应当使得每次收缩区间，最小值仍然在区间内。 nums[mid] num
二分法之旋转数组
renwu
09-08 465
例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2]。例如，将数组[1,2,3,4,5,6]的前3个元素进行旋转变为[4,5,6,1,2,3]，然后就是查找指定的元素，或者返回数组中最小的元素等等算法要求，也会根据难易程度，规定数组中是否存在重复元素。, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4]
二分法（旋转数组）
weixin_42628517的博客
10-28 375
1、先说二分法 二分法只对有序数组有效！ 使用二分法需要四个参数：数组的起始值，数组的结尾值，数组的中位值，目标值。 三种情况： 中位值就是目标值：1 2 3 4 5 6 7 目标值在中位值左侧：1 2 3 4 5 6 7 目标值在中位值右侧：1 2 3 4 5 6 7 将中位值与目标值做对比后，更新上面四个参数 代码如下（摘自：https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&mid=2653198263&idx=2&sn=c071
二分法之旋转数组系列
AndyJ的学习之旅
07-11 275
LeetCode 189. 旋转数组 给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。 要求使用空间复杂度为 O(1) 的 原地 算法。 解法一　双重循环 class Solution: def rotate(self, nums: List[int], k: int) -> None: """ Do not return anything, modify nums in-place instead. """
【每日一算】旋转有序数组
scj1014的博客
08-23 283
在旋转有序数组中找出给定的一个整数，并返回该整数在数组中的下标？ //常规有序数组 int[] arr1 = {1,2,3,4,5} //旋转有序数组 int[] arr2 = {50,60,70,80,20,30,40} 解题思路： 假设最左边下标用left标识，最右边下标有right标识，中间整数下标用mid标识; 每次判断下标mid对应的整数值是否大于下标left对应整数值，如果大于，...
寻找旋转排序数组中的最小值（二分法）
qq_42745986的博客
05-31 1293
重点理解二分法的思路 二分法使用的前提: 数据集必须有此案后顺序(升序或者降序) 二分法功能一：查找 如果：nums[mid] = 6 < target(8) 右移left 如果：nums[mid] = 12> target(8) 左移right 如果left和right相等，则找到目标值 二分法功能二：找最小（大）值 流程图 题目： 已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。
剑指offer之 旋转数组的最小数字
01-20
二分法查找，也称为折半法，是一种在有序数组中查找特定元素的搜索算法。二分法查找的思路如下： （1）首先，从数组的中间元素开始搜索，如果该元素正好是目标元素，则搜索过程结束，否则执行下一步。 （2）如果目标...
(LeetCode)搜索旋转排序数组——二分法
简十三的博客
07-15 2061
整数数组 nums 按升序排列，数组中的值 互不相同 。 在传递给函数之前，nums 在预先未知的某个下标 k（0
旋转有序数组
Rainer_Guo的博客
06-11 684
要求 　　给定一个没有重复元素的旋转数组（它对应的原数组是有序的），求给定元素在旋转数组内的下标（不存在的返回-1）。 例子 有序数组{0，1，2，3，4，5，6，7}对应的旋转数组为{3，4，5，6，7，0，1，2}（左旋、右旋效果相同）。 查找元素5，返回结果2； 查找元素8，返回结果-1。 变形 旋转有序数组找最小值下标 分析 　　可以轻易地想到遍历一遍O（n）时间可以得到结果，但是并不是最好的结果；利用有序的特点，可以轻易的想到二分查找的方法。经过旋转后的数组总是可以分...
Sorting&Searching 旋转数组二分法查找 @CareerCup
11-29 1315
就是3种情况，写在注释里了 package Sorting_Searching; /** * Given a sorted array of n integers that has been rotated an unknown number of * times, give an O(log n) algorithm that finds an element in the ar
旋转数组中的最小数字（特殊二分法）
Avalon
08-08 261
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 ...
[剑指Offer] 6.旋转数组的最小数字（二分法）
NULL
11-20 326
题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 【思路1】直接调用快排~~~ 1 class Solution { 2 public: 3 int min
[二分查找] 旋转数组
qq_51533157的博客
09-03 870
mid将旋转数组分为两块区间，但第一块区间的值的条件并不是简单的x
旋转数组的二分法查找
冰焰·
09-02 888
/* 一数组， array [] = {1,2,3,4,5,6,7,8,9}; 从某一位置开始旋转，变为以下数组 array_ex[] = {6,7,8,9,1,2,3,4,5}; 现在给定一个数值x，查找x是否在该数组array_ex中 算法思想:1.如果数组为有序数组，没有移位的话，则直接用二分法查找即可 2.如果有移位的话，则满足arr[left] >= arr[right].出
62. 搜索旋转排序数组（用二分法解决旋转排序无重复元素数组）、63. 搜索旋转排序数组 II (二分法对于left=mid=right)的旋转排序数组不使用）
jyh的博客
05-29 431
假设有一个排序的按未知的旋转轴旋转的数组(比如，0 1 2 4 5 6 7 可能成为4 5 6 7 0 1 2)。给定一个目标值进行搜索，如果在数组中找到目标值返回数组中的索引位置，否则返回-1。 你可以假设数组中不存在重复的元素。 样例 给出[4, 5, 1, 2, 3]和target=1，返回 2 给出[4, 5, 1, 2, 3]和target=0，返回 -1  分析： 这道题让...
33. 搜索旋转排序数组【二分法】
qq_42974800的博客
04-07 140
33. 搜索旋转排序数组【二分法】 描述：假设按照升序排序的数组在预先未知的某个点上进行了旋转。 ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。 你可以假设数组中不存在重复的元素。 你的算法时间复杂度必须是 O(log n) 级别。 示例 1: 输入: nums = ...
LeetCode - 旋转数组类总结（二分法）
much efforts, much luck
02-09 329
搜索旋转排序数组 假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。你可以假设数组中不存在重复的元素。你的算法时间复杂度必须是 O(log n) 级别。 示例 1: 输入: nums = [4,5,6,7,0,1,2],...
C语言二分法查找有序数组，区间位置
最新发布
07-04
C语言中的二分查找（也称为折半查找）是在有序数组中寻找特定元素的一种高效算法。它的基本思想是每次比较中间元素和目标值，如果相等则返回该位置；如果不等，则根据目标值与中间元素的大小关系决定下次查找应在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值