Search in a Rotated Sorted Array

Author: fishercoder1534

README.md

@@ -213,6 +213,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |39|[Combination Sum](https://leetcode.com/problems/combination-sum/)|[Solution](../../blob/master/src/stevesun/algorithms/CombinationSum.java)|O(k*n^k)|O(k)|Medium|Backtracking
 |38|[Count and Say](https://leetcode.com/problems/count-and-say/)|[Solution](../../blob/master/src/stevesun/algorithms/CountandSay.java)|O(n*2^n)|O(2^n)|Easy| Recursion, LinkedList
 |34|[Search for a Range](https://leetcode.com/problems/search-for-a-range/)|[Solution](../../blob/master/src/stevesun/algorithms/SearchForARange.java)|O(logn)|O(1)|Medium|Array, Binary Search
+|33|[Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/)|[Solution](../../blob/master/src/stevesun/algorithms/SearchinRotatedSortedArray.java)|O(logn)|O(1)|Hard|Binary Search
 |32|[Longest Valid Parentheses](https://leetcode.com/problems/longest-valid-parentheses/)|[Solution](../../blob/master/src/stevesun/algorithms/LongestValidParentheses.java)|O(n)|O(n)|Hard|Stack, DP
 |31|[Next Permutation](https://leetcode.com/problems/next-permutation)|[Solution](../../blob/master/src/stevesun/algorithms/NextPermutation.java)|O(n)|O(1)|Medium|Array
 |28|[Implement strStr()](https://leetcode.com/problems/implement-strstr/)|[Solution](../../blob/master/src/stevesun/algorithms/ImplementStrStr.java)|O(n)|O(1)|Easy| String

src/stevesun/algorithms/SearchinRotatedSortedArray.java

@@ -0,0 +1,118 @@
+package stevesun.algorithms;
+
+/**
+ * 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.
+ */
+public class SearchinRotatedSortedArray {
+
+    public int search(int[] A, int target) {
+        int len = A.length;
+        if (len == 0)
+            return -1;
+        if (len == 1) {
+            if (A[0] == target) {
+                return 0;
+            } else {
+                return -1;
+            }
+        }
+        int watershed = A[0];
+        int watershedIndex = 0;
+        for (int i = 0; i < len - 1; i++) {
+            if (A[i] > A[i + 1]) {
+                watershed = A[i];
+                watershedIndex = i;
+                break;
+            }
+        }
+        System.out.println("watershed = " + watershed + "\twatershedIndex = "
+                + watershedIndex);
+
+        if (target == watershed)
+            return watershedIndex;
+        else if (target > watershed) {
+			/*
+			 * here is the tricky part: when target is greater than watershed,
+			 * it's also possible that this list is ZERO rotated, i.e. it didn't
+			 * rotate at all! Then at this moment, watershed is not the largest
+			 * element int this array, so we need to binary search this whole
+			 * array.
+			 */
+            if (watershedIndex == 0) {
+                int start = 0;
+                int end = len - 1;
+                int mid = (start + end) / 2;
+                while (start <= end) {
+                    if (target > A[mid]) {
+                        start = mid + 1;
+                        mid = (start + end) / 2;
+                    } else if (target < A[mid]) {
+                        end = mid - 1;
+                        mid = (start + end) / 2;
+                    } else if (target == A[mid]) {
+                        return mid;
+                    }
+                }
+                return -1;
+            } else
+                return -1;
+        } else if (target < watershed) {
+			/*
+			 * target could be in either part of this sorted array, then we
+			 * check if target is greater than A[0], if so, then search in the
+			 * first part, if not, then check if it is greater than A[len - 1],
+			 * if so, return -1, if not, search in the second part
+			 */
+
+            if (target == A[0]) {
+                return 0;
+            } else if (target > A[0]) {
+                int start = 1;
+                int end = watershedIndex - 1;
+                int mid = (start + end) / 2;
+                while (start <= end) {
+                    if (target > A[mid]) {
+                        start = mid + 1;
+                        mid = (start + end) / 2;
+                    } else if (target < A[mid]) {
+                        end = mid - 1;
+                        mid = (start + end) / 2;
+                    } else if (target == A[mid]) {
+                        return mid;
+                    }
+                }
+                return -1;
+            } else if (target < A[0]) {
+                if (target == A[len - 1]) {
+                    return len - 1;
+                } else if (target > A[len - 1]) {
+                    return -1;
+                } else if (target < A[len - 1]) {
+                    int start = watershedIndex + 1;
+                    int end = len - 2;
+                    int mid = (start + end) / 2;
+                    while (start <= end) {
+                        if (target > A[mid]) {
+                            start = mid + 1;
+                            mid = (start + end) / 2;
+                        } else if (target < A[mid]) {
+                            end = mid - 1;
+                            mid = (start + end) / 2;
+                        } else if (target == A[mid]) {
+                            return mid;
+                        }
+                    }
+                    return -1;
+                }
+            }
+        }
+        return -1;
+    }
+
+}