LeetCode_Search in Rotated Sorted Array

一.题目

Search in Rotated Sorted Array

   Total Accepted: 41879  Total Submissions: 144919 My Submissions

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.

Show Tags

Have you met this question in a real interview?  

Yes

 

No

Discuss

二.解题技巧

    由于这道题出现了旋转的情况，即比第一个元素小的元素可能出现在数值的后半段或者不出现。因此，可以考虑采用变种的二分查找，即在比较中间元素与目标之前，先比较第一个元素与目标的关系，这个时候，会出现三种情况：

1.第一个元素刚好等于目标，返回第一个元素的坐标，函数结束；

2.第一个元素大于目标，那么目标就可能存在被旋转到数组后面的情况，这个时候，还要比较与数组中间元素的关系，这个时候又会有三种情况：

a.中间元素大于第一个元素，这个时候，目标可能存在于数组的后半段中，递归调用函数，寻找目标的坐标；

b.中间元素等于目标，返回中间元素的坐标，函数结束；

c.中间元素小于第一个元素，这个时候，又可以分为两种情况进行：

(1).中间元素小于目标元素，那么目标元素可能存在于数组的后半段中，递归调用函数，寻找目标的坐标；

(2).中间元素大于目标元素，那么目标元素可能存在于数组的前半段中，递归调用函数，寻找目标的坐标；

3.第一个元素小于目标，这是也有三种情况需要考虑：

a.中间元素等于目标元素，返回中间元素的坐标，函数结束；

b.中间元素大于第一个元素，这个时候，也有两种情况要考虑：

(1).中间元素大于目标，那么目标元素可能存在于数组的前半段中，递归调用函数，寻找目标的坐标；

(2).中间元素小于目标，那么目标元素可能存在于数组的后半段中，递归调用函数，寻找目标的坐标；

c.中间元素小于第一个元素，那么目标元素可能存在于数组的前半段中，递归调用函数，寻找目标的坐标；

   当然，还需要考虑数组的元素个数为0，1, 2,的情况，以及对于递归的过程中数组的起始位置坐标以及数组中元素的个数，这些才是这道题的难点所在，我也是调试了很久才调通代码的。

三.实现代码

int search(int A[], int n, int target)
{
    if (n < 1)
    {
        return -1;
    }

    if (n == 1)
    {
        if (A[0] == target)
        {
            return 0;
        }

        return -1;
    }

    if (n == 2)
    {
        if (A[0] == target)
        {
            return 0;
        }

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


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

    if (A[n / 2] == target)
    {
        return n / 2;
    }

    if (A[0] > target)
    {
        if (A[0] < A[n / 2])
        {
            int Index = search((A + n / 2), (n - n / 2 ), target);
            if (Index == -1)
            {
                return -1;
            }
            return Index + n / 2;
        }

        if (A[n / 2] < target)
        {
            int Index = search((A + n / 2), (n - n / 2), target);
            if (Index == -1)
            {
                return -1;
            }
            return Index + n / 2;
        }

        return search(A, (n / 2), target);

    }
    else
    {
        if (A[0] < A[n / 2])
        {
            if (A[n / 2] < target)
            {
                int Index = search((A + n / 2), (n - n / 2), target);
                if (Index == -1)
                {
                    return -1;
                }
                return Index + n / 2;
            }
            return search(A, (n / 2), target);
        }
        return search(A, (n / 2), target);
    }
}

四.体会

    这答题的解题思路不难，难的地方在于边界条件和递归过程中的数组的第一个元素的指针设置和数组元素个数的设置上面，边界条件才是面试题考查的重点啊。

版权所有，欢迎转载，转载请注明出处，谢谢。