LeetCode--Search in Rotated Sorted Array

问题I：一个排好序的数组，在某个未知轴心旋转了。例如[0,1,2,4,5]–>[4,5,0,1,2];现在给定一个target，让你求是否在此旋转后的数组中。

此时，应该假设数组中没有相同元素存在。

当然，时间复杂度要为O(logn)。

分析I：旋转后的数组，已经无法安装平常的二分查找在做了。。为了得到这个结论，我试了很多限制条件，仍然无法利用平常的二分查找。因此我的做法是，先找到旋转的轴心。轴心的左侧和右侧都是排好序的数组了，因此可以利用二分查找了。此时的诗句复杂度应该为O(2*logn) 。但好像我只能如此了。请大神赐教啊。上代码：

[code]#include <iostream>
#include<vector>
using namespace std;
/*Problem: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.

Tags: Array ;Binary Search
Similar Problems :(M) Search in Rotated Sorted Array II ; (M) Find Minimum in Rotated Sorted Array

*/
    int search(vector<int>& nums, int target) {
        int n=nums.size();
        if(n==0)return -1;
        int low=0,high=n-1;
        while(low<high){
            int mid=(low+high)/2;
            if(nums[mid]>nums[low])low=mid;
            else if(nums[mid]<nums[low])high=mid;
            else break;
        }
        if(target>=nums[0])low=0;
        else {high=n-1;low++;}
        while(low<=high){
            int mid=(low+high)/2;
            if(target==nums[mid])return mid;
            else if(target>nums[mid])
                low=mid+1;
            else high=mid-1;
        }
        return -1;
    }
int main()
{
    vector<int> nums={1,3};
    int res=search(nums,3);
    cout << "Hello world!" <<res<< endl;
    return 0;
}

恩，又发现个还不错的解决方法：

[code]    int search_II(vector<int>&nums,int target){
        int n=nums.size();
        if(n==0)return -1;
        int low=0,high=n-1;
        while(low<=high){
            int mid=(low+high)/2;
            if(nums[mid]==target)return mid;

            if(nums[mid]>nums[low]){//left part is sorted
                if(nums[mid]>target&&target>=nums[low])high=mid-1;
                else low=mid+1;
            }
            else if(nums[mid]<nums[low]){//right part is sorted.
                if(nums[mid]<target&&target<=nums[high])low=mid+1;
                else high=mid-1;
            }
            else low++;

        }
        return -1;
    }

问题II：一个排好序的数组，在某个未知轴心旋转了。例如[0,1,2,4,5]–>[4,5,0,1,2];现在给定一个target，让你求是否在此旋转后的数组中。

此时，假设数组中存在相同元素。应该如何编程？

分析II：此问题最坏时间复杂度为O(n)，平均时间复杂度还是可以达到O(logn)的。比线性遍历方法好那么点。此方法为参考别人的代码。真是学习了。

Code：

[code]/*Problem: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.

Tags: Array;  Binary Search
Similar Problems:(H) Search in Rotated Sorted Array

*/
    bool search(vector<int>& nums, int target) {
        int left = 0, right =  nums.size()-1, mid;

        while(left<=right)
        {
            mid = (left + right)/2 ;
            if(nums[mid] == target) return true;

            if( (nums[left] == nums[mid]) && (nums[right] == nums[mid]) ) {++left; --right;}

            else if(nums[left] <= nums[mid])//left part should be sorted.
            {
                if( (nums[left]<=target) && (nums[mid] > target) ) right = mid-1;
                else left = mid + 1;
            }
            else //nums[left]>nums[mid] menas right part should be sorted .
            {
                if((nums[mid] < target) &&  (nums[right] >= target) ) left = mid+1;
                else right = mid-1;
            }
        }
        return false;
    }

问题III：一个排好序的数组，在某个未知轴心旋转了。例如[0,1,2,4,5]–>[4,5,0,1,2];让你求是否在此旋转后的数组中的最小元素。

此时，假设数组中不存在相同元素。应该如何编程？

分析III：逻辑上很简单的东西。加强代码实现能力！！

Code：

[code]/*Problem:Find Minimum 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).

Find the minimum element.

You may assume no duplicate exists in the array.

Tags :Array ;Binary Search
Similar Problems :(H) Search in Rotated Sorted Array ;(H) Find Minimum in Rotated Sorted Array II
*/

    int findMin(vector<int>& nums) {
        int n=nums.size();
        if(n==0)return -1;
        int low=0,high=n-1;
        if(nums[low]<=nums[high])return nums[low];
        while(low<high){
            int mid=(low+high)/2;
            if(nums[mid]>nums[low])low=mid;
            else if(nums[mid]<nums[low])high=mid;
            else break;
        }
        if(low==high)
        return nums[low];
        else
        return nums[low]>nums[high]?nums[high]:nums[low];

    }