[Leetcode]_33 Search in Rotated Sorted Array

/**
*  Index: 33
*  Title: Search in Rotated Sorted Array
*  Author: ltree98
**/

这道题，刚开始没看懂。

给定一个增序数组被旋转的数组，查找某个数在这个数组的位置，没有返回-1。

假定被查找的数在数组内最多有一个。

它的意思是，给一个数组，然后数组会被预先旋转一下，然后找数。

那么问题来了，给的数组A，旋转后数组B。

返回的序列号是数字在A的序列号，还是在B的序列号呢？

虽然，参数传入的是B数组，但是因为是增序数组，所以，可以推导出原数组A。

于是，折腾了一下，用 O(n) 的暴力查找。

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

发现A了，证明，找的是旋转后数组的序列号。

为了进一步证明，用了普通的二分查找。

class Solution {
public:
int search(vector<int>& nums, int target) {
int l = 0, h = nums.size()-1;
int m = (l+h)/2;

while(l <= h)   {
if(nums[m] > target)
h = m-1;
else if(nums[m] < target)
l = m+1;
else
return m;
m = (l+h)/2;
}

return -1;
}
};

发现，卡在了[3,1] - WA。

再次证明是找旋转后数组的序列号。

所以，这道题，其实就是查找两段增序数组合成的数组中的数字，而且这两段数组没有重复的数字。

二分查找的变异

n[m] < target => n[h] < target => n[m] <= n[h] (target在左边) => h = m-1

n[m] > n[h] (target在右边) => l = m+1

n[h] > target (target在右边) => l = m+1

n[h] == target => 返回 h

n[m] > target => n[l] < target (target在左边) => h = m-1

n[l] > target => n[m] >= n[l] (target在右边) => l = m+1

n[m] < n[l] (target在左边) => h = m-1

n[l] == target => 返回 l

n[m] == target => 返回 m

class Solution {
public:
int search(vector<int>& nums, int target) {
int l = 0, h = nums.size()-1;
int m = (l+h)/2;

while(l <= h)   {
if(nums[m] > target)    {
if(nums[l] < target)    h = m-1;
else if(nums[l] > target)
if(nums[m] >= nums[l])  l = m+1;
else    h = m-1;
else    return l;
}
else if(nums[m] < target)   {
if(nums[h] < target)
if(nums[m] <= nums[h])  h = m-1;
else    l = m+1;
else if(nums[h] > target) l = m+1;
else    return h;
}
else
return m;
m = (l+h)/2;
}

return -1;
}
};