搜索排序旋转数组

搜索旋转排序数组

首先我们完成基本有序数组中的二分查找

int[] nums = {1,2,3,4,5,6};
int start = 0
int end = nums.length - 1;
int pos = 0;
while(start < end)
{
    int mid = (start + end) / 2;
    if(nums[mid] == target)
        return mid;
    if(nums[mid] > target)
    {
        pos = mid;
        right = mid - 1;
    }
    else
    {
        left = mid + 1;
    }
}

31.搜索旋转排序数组

public int search(int[] nums, int target) {
    //int[] nums = {4,5,1,2,3};
    int start = 0;
    int end = nums.length - 1;
    while(start <= end)
    {
        int mid = (start + end) / 2;
        if(nums[mid] == target)
            return mid;
        // 当mid落在前半段，即nums[mid] >= nums[0]
        if(nums[mid] >= nums[0])
        {
             //1.target < nums[0] -> left = mid + 1;
             //2.nums[0] <= target < nums[mid] ->right = mid - 1;
             //3.nums[mid] < target -> left = mid + 1;
             if(target >= nums[0] && target < nums[mid])
                end = mid - 1;
             else
                start = mid + 1;
        }
        // 当mid落在后半段
        else
        {
            //1.target > nums[nums.length - 1] -> right = mid - 1;
            //2.nums[mid] < target <= nums[nums.length - 1] -> left = mid + 1;
            //3.target < nums[mid]  -> right = mid - 1
            if(target > nums[mid] && target <= nums[nums.length - 1])
                start = mid + 1;
            else
                end = mid - 1;  
        } 
    }
    return -1;
}

搜索排序数组2

81.搜索旋转数组2

这道题是一个非常局部的二分搜索 对于nums[mid]，排除nums[mid] == target 后存在这些情况：

1. nums[mid] == nums[start]
2. nums[mid] > nums[start]
3. nums[mid] < nums[start]

情况1：nums[mid] == nums[start] 无法判断 是1,1,3,1,1(start = 0, mid = 1 || start= 0, mid = 3)

这种情况下无法判断应该往哪一段寻找target，只能使start = start + 1

情况2: nums[mid] > nums[start]

这个时候nums[start, mid]是存在顺序的，又要引出新的讨论分支

1. nums[start] <= target < nums[mid] -> end = mid -1;
2. target < nums[start] ｜｜ nums[mid] < target ->start = mid + 1;

情况3 nums[mid] < nums[start]

这个时候nums[mid, end]是有序的，引出新的讨论分支

1. nums[mid] < target <= nums[end] -> start = mid + 1;
2. target < nums[mid] || target > nums[end] -> end = mid - 1;

代码

class Solution {
public boolean search(int[] nums, int target) {
    int start = 0;
    int end = nums.length - 1;
    while(start <= end)
    {
        int mid = (start + end) / 2;
        if(nums[mid] == target)
            return true;
        if(nums[mid] == nums[start])
        {
            start += 1;
            continue;
        }
        if(nums[mid] > nums[start])
        {
            if(nums[start] <= target && target < nums[mid])
            {
                end = mid - 1;
            }
            else
                start = mid + 1;
        }
        else
        {
            if(nums[mid] < target && target <= nums[end])
            {
                start = mid + 1;
            }
            else
                end = mid - 1;
        }
    }
        return false;
    }
}

本文使用 mdnice 排版