[Leetcode]33(81). Search in Rotated Sorted Array I, II

题目大意：

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.

一. 没有重复元素

分析：{0，1，2，4，6，7，8}

情况1：{ 8，0，1，2，4，6，7}

情况2：{2，4，6，7，8，0，1}
I. nums[mid] = target时, 返回索引；
II.
nums[mid] != target时： 

   1.两种情况都有半边是完全排序好的

   2.原数组起始元素被转到nums[mid]的左半边，如情况1，nums[mid]<nums[start]

      (1). target在右半边，则依次逼近，因为右半边就是正常的排序好的数组

      (2). target在左半边，就是else的情况

   3.原数组起始元素被转到nums[mid]的右半边，如情况2，也是情况1的else，即nums[mid]>=nums[start]

      (1). target在左半边，则依次逼近，因为左半边就是正常的排序好的数组

      (2). target在右半边，就是else的情况 

public class Solution {
/**
*@param A : an integer rotated sorted array
*@param target :  an integer to be searched
*return : an integer
*/
public int search(int[] A, int target) {
if(A==null || A.length==0){
return -1;
}

int start=0,end=A.length-1;
while(start+1<end){
int mid=start+(end-start)/2;
if(A[mid]==target){
return mid;
}
if(A[start]<A[mid]){
if(A[start]<=target && target<=A[mid]){
end=mid;
}else{
start=mid;
}
}else{
if(A[mid]<=target && target<=A[end]){
start=mid;
}else{
end=mid;
}
}
}

if(A[start]==target){
return start;
}
if(A[end]==target){
return end;
}
return -1;
}
}

二. 有重复元素

九章的解释是说这题在面试中不会让实现完整程序

考点是能否想到最坏情况比如序列 {1，1，...1，1}中有1个0寻找target=0，此时复杂度退化到O(n)

由于for循环的时间复杂度是O(n)，直接写个for循环就好

public class Solution {
/**
* param A : an integer ratated sorted array and duplicates are allowed
* param target :  an integer to be search
* return : a boolean
*/
public boolean search(int[] A, int target) {
if(A==null || A.length==0){
return false;
}
for(Integer n:A){
if(n==target){
return true;
}
}
return false;
}
}

二分实现分析：{1，2，3，3，3，3}
如果不能确定是否为递增：{3，3，3，3，1，2}，跳过此时的start看向下一位

I. nums[mid] = target时, 返回索引；
II. nums[mid] != target时： 
    所以在最坏情况下，算法的复杂度退化成了O(n) ，比如序列 {2，2， 2，2，2，2}中寻找target=1。

public class Solution {
/**
* param A : an integer ratated sorted array and duplicates are allowed
* param target :  an integer to be search
* return : a boolean
*/
public boolean search(int[] A, int target) {
if(A==null || A.length==0){
return false;
}

int start=0;
int end=A.length-1;
while(start+1<end){
int mid=start+(end-start)/2;
if(A[mid]==target){
return true;
}
if(A[start]<A[mid]){
if(A[start]<=target && target<=A[mid]){
end=mid;
}else{
start=mid;
}
}else if(A[start]>A[mid]){
if(A[mid]<=target && target<=A[end]){
start=mid;
}else{
end=mid;
}
}else{                                      //确定不了是否递增，就跳过重复值往下一个看即可
start++;
}
}

if(A[start]==target){
return true;
}else if(A[end]==target){
return true;
}else{
return false;
}
}
}