LeetCode081 Search in Rotated Sorted Array II

详细见：leetcode.com/problems/search-in-rotated-sorted-array-ii

Java Solution: github

package leetcode;

public class P081_SearchInRotatedSortedArrayII {
	public static void main(String[] args) {
		int[] nums = null;
//		nums = new int[] {4,5,5,6,7,0,1,2};
//		nums = new int[] {3, 1};
		nums = new int[] {4,5,6,7,0,1,2};
		int target = 2;
		System.out.println(new Solution().search(nums, target));
	}
	/*
	 * 	AC
	 * 	试错型AC
	 * 	1 ms
	 */
	static class Solution {
	    public boolean search(int[] nums, int target) {
	    	if (nums == null || nums.length == 0)
	    		return false;
	    	if (nums.length == 1)
	    		return nums[0] == target;
	    	int breakIndex = 1;
	    	while (true) {
	    		if (breakIndex == nums.length 
	    				|| nums[breakIndex - 1] > nums[breakIndex])
	    			break;
	    		breakIndex ++;
	    	}
	    	int ans = binaryIndex(nums, 0, breakIndex - 1, target);
	    	if (ans != -1)
	    		return true;
	    	return binaryIndex(nums, breakIndex, nums.length - 1, target) != -1;
	    }
	    int binaryIndex(int[] nums, int sti, int eni, int target) {
	    	if (sti > eni)
	    		return -1;
	    	int cal = (nums[sti] - target) * (nums[eni] - target);
	    	if ( cal  > 0 )
	    		return -1;
	    	else if (cal == 0)
	    		return sti;
	    	while (sti <= eni) {
	    		int mid = (sti + eni) >> 1;
	    		if (nums[mid] == target) {
	    			return mid;
	    		} else if (nums[mid] > target) {
	    			eni = mid - 1;
	    		} else {
	    			sti = mid + 1;
	    		}
	    	}
	    	return -1;
	    }
	}
}

C Solution: github

/*
    url: leetcode.com/problems/search-in-rotated-sorted-array-ii
    AC 6ms 0.00%
*/

#include <stdio.h>
#include <stdlib.h>

#define bool int

bool _just(int* n, int ni, int nn, int t) {
    int nm = 0;
    if (ni > nn) return 0;
    while (ni < nn) {
        nm = (ni + nn) / 2;
        if (n[nm] == t) return 1;
        if (n[nm] > t) nn = nm - 1;
        else ni = nm + 1;
    }
    return 0;
}

bool _search(int*n ,int ni, int nn, int t) {
    int nm = (ni + nn) / 2;
    if (ni > nn) return 0;
    if (n[ni] == t || n[nn] == t || n[nm] == t) return 1;
    if (n[nm] > n[ni]) {
        if (_just(n, ni, nm, t)) return 1;
        return _search(n, nm+1, nn, t);
    } else if (n[nm] < n[ni]) {
        if (_just(n, nm+1, nn, t)) return 1;
        return _search(n, ni, nm - 1, t);
    } else {
        return _search(n, ni+1, nm-1, t) || _search(n, nm+1, nn-1, t);
    }
}

bool search(int* n, int nn, int t) {
     return _search(n, 0, nn-1, t);
}

int main() {
    int n[] = {3, 1, 1};
    printf("answer is %d\r\n", search(n, 3, 3));
}

Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/search-in-rotated-sorted-array-ii
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年4月19日
    @details:    Solution: 49ms 52.19%
'''

class Solution(object):
    def ss(self, n, ni, nj, t):
        while ni < nj:
            nm = (ni + nj) // 2
            if n[nm] == t: return True
            if n[nm] > t: nj = nm-1
            else: ni = nm+1
        return False
    
    def s(self, n, ni, nj, t):
        if ni > nj: return False
        if n[ni] == t or n[nj] == t: return True
        nm = (ni + nj) // 2
        if n[nm] == t: return True
        if n[nm] > n[ni]:
            if self.ss(n, ni, nm, t): return True
            return self.s(n, nm+1, nj-1, t)
        elif n[nm] < n[ni]:
            if self.ss(n, nm, nj, t): return True
            return self.s(n, ni+1, nm-1, t)
        else:
            return self.s(n, ni+1, nm-1, t) or \
                self.s(n, nm+1, nj-1, t)
        
    def search(self, n, t):
        """
        :type n: List[int]
        :type t: int
        :rtype: bool
        """
        nn = 0 if n == None else len(n)
        if nn == 0: return False
        return self.s(n, 0, nn-1, t)