LeetCode--medium--search_in_rotated_array_ii_81

summary:

binary search

package myapp.kit.leetcode.top200;

/**
 * 81
 * medium
 * https://leetcode.com/problems/search-in-rotated-sorted-array-ii/
 *
 * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
 *
 * (i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).
 *
 * You are given a target value to search. If found in the array return true, otherwise return false.
 *
 * Example 1:
 *
 * Input: nums = [2,5,6,0,0,1,2], target = 0
 * Output: true in
 * Example 2:
 *
 * Input: nums = [2,5,6,0,0,1,2], target = 3
 * Output: false
 * Follow up:
 *
 * This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
 * Would this affect the run-time complexity? How and why?
 * Accepted
 *
 *
 * @author huangdingsheng
 * @version 1.0, 2020/7/10
 */
public class search_in_rotated_array_ii_81 {

    public boolean search(int[] nums, int target) {
        return process(nums, target, 0, nums.length - 1);
    }

    private boolean process(int[] nums, int target, int l, int r) {
        if (l > r) {
            return false;
        }
        int mid = (l + r) / 2;
        if (nums[mid] == target) {
            return true;
        }
        if ((nums[l] == nums[mid]) && (nums[mid] == nums[r])) {
            l++;
            r--;
        }
        if (l > r) {
            return false;
        }

        if (nums[l] <= nums[mid]) {
            if (target >= nums[l] && target <= nums[mid]) {
                return process(nums, target, l, mid - 1);
            }
            return process(nums, target, mid + 1, r);
        } else {
            if (target >= nums[mid] && target <= nums[r]) {
                return process(nums, target, mid + 1, r);
            }
            return process(nums, target, l, mid - 1);
        }
    }
}