[array] leetcode - 33. Search in Rotated Sorted Array - Medium

leetcode - 33. Search in Rotated Sorted Array - Medium

descrition

Suppose an array sorted in ascending order 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.

解析

两种方法的时间复杂度和空间复杂度都是一样的，不过思考的思路有所不同，不过根本都是对二分查找的改进。方法 1 对应代码 int searchDirectly(vector

注意点：

当 target 找不到的时候返回 -1

可以假设数组中的元素都是唯一的 （这是代码优化的关键！）

一般的：

直接在原数组上进行二分查找。对于数组 arry[0,...,n-1] 可以将其分成两个部分 left_part = arry[0,...,imax], right_part=arry[imax+1, ..., n-1]，其中 imax 指向数组中最大的元素，那么 left_part 和 right_part 都是递增的，并且 left_part 中所有的值都大于 right_part 中的值。

对于 binary search，假设 [ileft, ... , irigt] 确定 arry 中的一个子数组。下面就讨论，我们如何在每次查找中将查找空间减少一半的思路。

每次而分查找我们需要计算 imid = (ileft + iright) / 2，即中间元素的位置，将数组均分成两半。这时我们可以根据 imid 的位置来确定下一次的查找范围。

condition1: 如果 arry[ileft] < arry[imid] : 说明 imid 在 left_part 的 ascending 子数组中

condition2: 如果 arry[imid] < arry[irigh] : 说明 imid 在 rigt_part 的 ascending 子数组中

注意：因为 left_part < right_part ，因此以上两种情况是对立的。如果 ileft, imid, iright 指向的 3 个数相等，我们将无法判断 imid 处在数组的那个部分，也就无法达到划分的目的，这是题意的关键优化点。

方法 1

如果 condition1 成立，那么 [ileft, ..., imid] 是递增有序的

如果 target 在 [ileft, ..., imid] 区间内，则 ileft = imid-1

否则 ileft = imid + 1

如果 condition2 成立，那么 [imid, ..., iright] 是递增有序的

如果 target 在 [imid, ..., iright] 区间内，则 ileft = imid + 1

否则 iright = imid - 1

每一次查找都能使搜索空间减半。具体实现看代码，注意细节和边界条件。

方法 2

我们可以先找到数组中最小值的位置 imin，那么相对于原来递增有序的数，新的 rotated 数组中元素的位置 i' = (i + imin)%n。比如 4 5 6 7 0 1 2， imin = 4，相当于原数组 0 1 2 4 5 6 7 循环右移了 imin 步。找最小值的位置也是使用折半查找的思想，时间复杂度 O(log(n))。

针对原数组 0 1 2 4 5 6 7 使用而分查找，每次而分查找比较时，使用 i' = (i + imin)%n 计算真是的 middle 位置。这样可以达到减办的效果。时间复杂度 O(log(n)) 。

具体实现查看代码。虽然这样的方法比钱前一种方法来说代码量大，实际上做了两次而分查找，但这里新地址的映射方式是个很好的思考思路。

code

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution{
public:
int search(vector<int>& nums, int target){
// You may assume no duplicate exists in the array.
//return searchDirectly(nums, target);
return searchAssist(nums, target);
}

// time-O(log(n)), space-O(1)
int searchDirectly(vector<int>& nums, int target){
int ileft = 0;
int iright = nums.size()-1;
while(ileft <= iright){
int imid = (ileft+iright)/2;
if(nums[imid] == target){
return imid;
}

// nums[imid] != target
if(nums[ileft] <= nums[imid]){
// nums[ileft,...,imid] is ascending
// Note: don't forget to check nums[ileft] == target
if(nums[ileft] <= target && target < nums[imid]){
iright = imid - 1;
}else{
ileft = imid + 1;
}

}else{
// nums[imid] < nums[iright]
// nums[imid,...,iright] is ascending
// Note: don't forget to check target == nums[iright]
if(nums[imid] < target && target <= nums[iright]){
ileft = imid + 1;
}else{
iright = imid - 1;
}
}

}

return -1;
}

// time-O(log(n)), space-O(1)
int searchAssist(vector<int>& nums, int target){
if(nums.empty())
return -1;

// the number of rotated of each element in nums
int irotated = findMinInRotatedArray(nums);
int n = nums.size();

int ileft = 0;
int iright = nums.size() - 1;
while(ileft <= iright){
int imid = (ileft + iright) / 2;
int imidReal = (imid + irotated) % n; // calculate the real index of middle value
if(nums[imidReal] == target){
return imidReal;
}else if (nums[imidReal] < target){
ileft = imid + 1;
}else{
// nums[imidReal] > target
iright = imid - 1;
}
}

return -1;
}

int findMinInRotatedArray(vector<int>& nums){
if(nums.empty())
return -1;
if(nums[0] < nums[nums.size()-1]) // nums in ascending
return 0;

// binary search
int ileft = 0;
int iright = nums.size() - 1;
while(ileft+1 < iright){
int imid = (ileft + iright) / 2;
if(nums[ileft] < nums[imid]){
ileft = imid;
}else{
// nums[imid] < nums[iright]
iright = imid;
}
}

// ileft point to the maximum
// iright point to the minimum

return iright;
}
};

int main()
{
return 0;
}