LeetCode 之 Search in Rotated Sorted Array I II — C/C++ 实现

Search in Rotated Sorted Array

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

假设一个有序的数组中的一些值以某点为中心发生了旋转，但不知道在哪个位置。

（如 0 1 2 4 5 6 7 可能变成 4 5 6 7 0 1 2）。

在数组中查找给定的值，若找到返回其在数组中的位置，否则返回-1.

假设数组中没有重复的数。

分析：

法1：顺序查找，时间复杂度为 O(n).

<pre name="code" class="cpp">int search(int* nums, int numsSize, int target) {
    int index = 0;
    
    if(!nums) //空
        return -1;
        
    for(; index < numsSize; ++index)
    {
        if(nums[index] == target)
        {
            return index;
        }
    }
    
    return -1;
}

法2：折半查找(C++)。

    对二分查找的改进算法。需要判断是否存在转折点，将中间值和右端值比较即可，先找出确定的递增区间，比如当 nums[mid] > nums[high] 时，转折点肯定在 mid 的右侧，此时 mid 左端为递增区间，则先判断 mid 左侧 high 和 low 的位置，其他情况都在 mid 右侧；当 nums[mid] < nums[high] 时，mid 到 high 之间肯定递增，则先判断此区间。

</pre><pre name="code" class="cpp">class Solution {
public:
    int search(vector<int>& nums, int target) {
        int numsSize = nums.size();
        if(!numsSize)
        {
            return -1;
        }
        
        int low = 0, high = numsSize - 1, mid = 0;
        //二分查找
        while(low <= high)
        {
            mid = (low + high) >> 1;//取中间位置
            
            if(nums[mid] == target)//找到
            {
                return mid;
            }
            else if(nums[mid] > nums[high])//mid右侧存在旋转
            {
                if(nums[mid] > target && nums[low] <= target) //在转折点左侧部分
                {
                    high = mid - 1;
                }
                else //在右侧，可能在旋转部分，也可能在左边递增部分更大值部分
                {
                    low = mid + 1;
                }
            }
            else //处在单调递增部分,mid 到 high 区间为递增
            {
                if(nums[mid] < target && nums[high] >= target)
                {
                    low = mid + 1;
                }
                else
                {
                    high = mid - 1;                    
                }
            }
        }
        
        return -1;
    }
};

Search in Rotated Sorted Array II

 

Follow up for "Search in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

Write a function to determine if a given target is in the array.

继续 "Search in Rotated Sorted Array".

假如数组中存在重复的值。

会不会影响时间复杂度？

写出一个函数查找数组中是否存在给定的值。

分析：

    方法和 I 一样，只是当 nums[mid] >= nums[high] 时,mid 左侧的为递增就不成立了，如 [4 5 1 1 1]。此时将 > 和 == 分开，若果相等，在 low 和 high-1 之间查找。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int numsSize = nums.size();
        if(!numsSize)
        {
            return -1;
        }
        
        int low = 0, high = numsSize - 1, mid = 0;
        //二分查找
        while(low <= high)
        {
            mid = (low + high) >> 1;//取中间位置
            
            if(nums[mid] == target)//找到
            {
                return true;
            }
            else if(nums[mid] < nums[high]) //mid 到 high 为递增
            {
                if(nums[mid] < target && nums[high] >= target)//在mid到high区间
                {
                    low = mid + 1;
                }
                else
                {
                    high = mid - 1;
                }
            }
            else if(nums[mid] > nums[high])//转折点在mid右侧
            {
                if(nums[mid] > target && nums[low] <= target) //target在转折点左侧
                {
                    high = mid - 1;
                }
                else
                {
                    low = mid + 1;
                }
            }
            else //nums[mid] == nums[high],此时在 low 和 high-1之间找
            {
                --high;
            }
        }
        
        return false;
    }
};