LeetCode 81. 搜索旋转排序数组 II

Posted 2023-04-05 poteitoutou

1

class Solution 
public:
    bool search(vector<int>& nums, int target) 
        int index = -1;
        for (int i = 0; i < nums.size() - 1; ++i)
            if (nums[i] > nums[i + 1]) index = i;
        
        if (index == -1)
            index = nums.size() - 1;
        
        return binarySearch(nums,target,-1,index) || binarySearch(nums,target,index,nums.size() - 1);

    
    bool binarySearch(vector<int>& nums,int target,int l,int r)
        //左开右闭
        while (l < r)
            int mid = l + ((r - l) >> 1) + 1;
            if (nums[mid] < target)
                l = mid;
            else if (nums[mid] > target)
                r = mid - 1;
            else
                return true;
            
        
        return false;
    
;

2

class Solution 
public:
    bool search(vector<int>& nums, int target) 
        //左闭右闭
        int start = 0;
        int end = nums.size()-1;
        while (start <= end)
            int mid = start + ((end - start) >> 1);
            if (nums[mid] == target) return true;
            if (nums[mid] == nums[start]) start++;
            else if (nums[mid] >= nums[start])  
                //左区间增序
                if (nums[mid] > target && target >= nums[start])
                    end = mid - 1;
                else
                    start = mid + 1;
                
            else
                //右区间增序
                if (nums[end] >= target && target > nums[mid])
                    start = mid + 1;
                else
                    end = mid - 1;
                
            
        
        return false;
    
;

LeetCode 81——搜索旋转排序数组 II

1. 题目

2. 解答

2.1. 方法一

基于 LeetCode 33——搜索旋转排序数组 中的方法二。

当 nums[mid] = nums[right] 时，比如 [1, 1, 2, 1, 1]，[1, 1, 0, 1, 1]，为了找到正确的转折点，我们查看 [mid, right] 之间有没有不等于 nums[mid] 的值，若有，则继续向右查找；否则向左查找。

class Solution {
public:
 
    int Binary_Search(vector<int>& nums, int left, int right, int target) 
    {
        int mid = 0;
        
        while(left <= right)
        {
            mid = left + (right - left) / 2;
            if (nums[mid] == target)
            {
                return mid;
            }
            else if(nums[mid] < target)
            {
                left = mid + 1;
            }
            else
            {
                right = mid - 1;
            }
        }
            
       return -1;     
    }
        
    bool search(vector<int>& nums, int target) {
        
        if (nums.size() == 0) return 0; // 数组为空
        
        int left = 0;
        int right = nums.size() - 1;
        int mid = 0;
        
        while(left < right)
        {
            mid = left + (right - left) / 2;
            
            if (nums[mid] > nums[right])
            {
                left = mid + 1;
            }
            else if (nums[mid] < nums[right])
            {
                right = mid;
            }
            else // nums[mid] = nums[right]
            {  
                int flag = 1;
                
                for (int i = mid; i < right; i++)
                {
                    int temp = nums[mid];
                    if (nums[i] != temp) // mid 到 right 之间有不等于 nums[mid] 的值，向右边查找
                    {
                        flag= 0;
                        left = mid + 1;
                        break;
                    }   
                }
                
                if (flag)
                {
                    right = mid; // mid 到 right 之间没有小于 nums[mid] 的值，向左边查找
                }
            }
        }
                        
        int a = Binary_Search(nums, 0, right-1, target);
        int b = Binary_Search(nums, right, nums.size() - 1, target);
                
        return a == -1 && b == -1 ? false : true;
        
    }
};

2.2. 方法二

基于 LeetCode 33——搜索旋转排序数组 中的方法三。

当 nums[mid] = nums[right] 时，比如 [1, 1, 2, 1, 1]，[1, 1, 0, 1, 1]，我们直接将右边界 right 减一，然后继续查找。

class Solution {
public:

    bool search(vector<int>& nums, int target) {
        
       int left = 0;
        int right = nums.size() - 1;
        int mid = 0;
        
        while(left <= right)
        {
            mid = left + (right - left) / 2;
            
            if (nums[mid] == target)
            {
                return true;
            }
            else if (nums[mid] < nums[right])  // nums[mid] 在右边升序的数据区间内    
            {
                if (nums[mid] < target && target <= nums[right]) left = mid + 1;
                else    right = mid - 1;
            }
            else if (nums[mid] > nums[right]) // nums[mid] 在左边升序的数据区间内    
            {
                if (nums[left] <= target && target < nums[mid]) right = mid - 1;
                else    left = mid + 1;
            }
            else // nums[mid] = nums[right]
            {
                right--;
            }
        }
        
        return false;
    }
};

获取更多精彩，请关注「seniusen」!