【二分法】1.33. 搜索旋转排序数组(力扣总结)

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [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], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        
        int L=0,R=nums.size()-1;
        
        while(L<=R){
            int  mid = L+(R-L)/2;
            if(nums[mid]==target) return mid;
            else if(nums[L]<=nums[mid]){
                if(target<nums[mid]&&target>=nums[L]){
                    R=mid-1;
                }
                else L=mid+1;
            }
            else {
                if(target>nums[mid]&&target<=nums[R]){
                    L=mid+1;
                }
                else R=mid-1;
            }
        }
        return -1;
    }
};

81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
示例 2:

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
进阶:

这是搜索旋转排序数组的延伸题目，本题中的 nums 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int L=0,R=nums.size()-1;
        
        while(L<=R){
            int  mid = L+(R-L)/2;
            if(nums[mid]==target) return true;
            if(nums[mid]==nums[L]){L++;continue;}
            if(nums[mid]==nums[R]){R--;continue;}

            else if(nums[L]<=nums[mid]){
                if(target<nums[mid]&&target>=nums[L]){
                    R=mid-1;
                }
                else L=mid+1;
            }
            else {
                if(target>nums[mid]&&target<=nums[R]){
                    L=mid+1;
                }
                else R=mid-1;
            }
        }
        return false;
    }
};

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

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

你可以假设数组中不存在重复元素。

示例 1:

输入: [3,4,5,1,2]
输出: 1
示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int findMin(vector<int>& nums) {
        //二分法:如果中间值比最右方值小,则最小值在左半段
        //如果最小值比最右方值大。则最小值在右半段
        int L=0;
        int R= nums.size()-1;
        //通过减小选择区间解决，也就是最后剩下的那个元素一定是最小值
        while(L<R){
            int mid = (L+R)/2;
            if(nums[mid]>nums[R])L = mid+1;
            else R=mid;
        }

        return nums[L];
    }
};

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

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

注意数组中可能存在重复的元素。

示例 1：

输入: [1,3,5]
输出: 1
示例 2：

输入: [2,2,2,0,1]
输出: 0
说明：

这道题是寻找旋转排序数组中的最小值的延伸题目。
允许重复会影响算法的时间复杂度吗？会如何影响，为什么？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int findMin(vector<int>& nums) {
        
       int L=0,R=nums.size()-1;
        while(L<R){
            int mid=(L+R)/2;
            if(nums[R]<nums[mid]){L =mid+1;}
            else if(nums[R]>nums[mid]){ R = mid;}
            else R= R-1;
        }
        return nums[L];
    }
};

来源：CSDN

作者：海绵大叔

链接：https://blog.csdn.net/weixin_42655231/article/details/103793131

标签

二分法

排序算法

target