LeetCode 33 — Search in Rotated Sorted Array（C++ Java Python）

题目： http://oj.leetcode.com/problems/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.

题目翻译：

假设一个有序数组在一个未知的位置旋转。
（即0 1 2 4 5 6 7可能变成4 5 6 7 0 1 2）。
给定一个目标值进行搜索。如果数组中存在则返回它的索引，否则返回-1。
可以假设数组中不存在重复的元素。

分析：
        类似二分查找，但判断处于哪个子区间要复杂一些。
C++实现：

class Solution {
public:
    int search(int A[], int n, int target) {
    	int left = 0;
    	int right = n - 1;

    	while(left <= right)
    	{
    		int mid = (left + right) / 2;

    		if(A[mid] == target)
    		{
    			return mid;
    		}

    		if(A[mid] >= A[left])
    		{
    			if(A[mid] > target && A[left] <= target)
				{
					right = mid - 1;
				}
				else
				{
					left = mid + 1;
				}
    		}
    		else
    		{
    			if(A[mid] < target && A[right] >= target)
    			{
    				left = mid + 1;
    			}
    			else
    			{
    				right = mid - 1;
    			}
    		}
    	}

    	return -1;
    }
};

Java实现：

public class Solution {
    public int search(int[] A, int target) {
		int left = 0;
		int right = A.length - 1;

		while (left <= right) {
			int mid = (left + right) / 2;

			if (A[mid] == target) {
				return mid;
			}

			if (A[mid] >= A[left]) { 
				if (A[mid] > target && A[left] <= target) {
					right = mid - 1;
				} else {
					left = mid + 1;
				}
			} else {
				if (A[mid] < target && A[right] >= target) {
					left = mid + 1;
				} else {
					right = mid - 1;
				}
			}
		}

		return -1;
    }
}

Python实现：

class Solution:
    # @param A, a list of integers
    # @param target, an integer to be searched
    # @return an integer
    def search(self, A, target):
        left = 0
        right = len(A) - 1
        
        while left <= right:
            mid = (left + right) / 2
            
            if A[mid] == target:
                return mid
            
            if A[mid] >= A[left]:
                if A[mid] > target and A[left] <= target:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
                if A[mid] < target and A[right] >= target:
                    left = mid + 1
                else:
                    right = mid - 1
            
        return -1

        感谢阅读，欢迎评论！