leetcode6:Search in Rotated Sorted Array

最新推荐文章于 2015-09-06 10:05:30 发布

BeLeaderOfMyLife

最新推荐文章于 2015-09-06 10:05:30 发布

阅读量508

点赞数

分类专栏： leetcode算法文章标签：算法 oj Search in Rotated So leetcode

本文链接：https://blog.csdn.net/shawjan/article/details/43021519

版权

leetcode算法专栏收录该内容

54 篇文章 0 订阅

订阅专栏

Search in Rotated Sorted Array

题目连接：https://oj.leetcode.com/problems/search-in-rotated-sorted-array/

runtimes：7ms

一、问题

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.

即有个循环数组，在其中找target元素，如果找到了返回index，找不到返回-1。

二、分析

这个问题有点水，你如果按照传统的思维从头扫描到尾只需要O(n)的时间，但是题目tip给出了binary search的字样，需要琢磨一下如何利用分支策略寻找，如果真的可以用那么就可以讲O(n)降成O(logN)的时间。分治思想如何运作的呢？首先对数组A的中间元素和target进行比较，是的话返回，不是的话找到递增的那一部分，如果元素在递增的部分，那么就继续按照分治思想搜索在递增部分中搜索target；否则就回到了原问题的子问题，即在数组A的子数组（A的非递增另外一部分）中搜索target。以此类推，直到找到target元素返回index或者返回-1为之。

三、小结

如上面分析所述，用从头扫描到尾的方法就可以在O(n)的时间内找到结果；

但是如果用分治思想的话，可以如此设计：搜索数组A，取A中间元素，如果等于target，返回index。如果不等，找出递增的那一部分子数组，假如是左边，则检测target是否在递增中，如果是，就继续递归搜索左边；否则搜索右边非递增部分，此时该问题也是原问题的子问题，即在数组A的子数组中搜索target元素。以此类推，直至得到结果。

四、方案

传统实现方案：

class Solution {
public:
    int search(int A[], int n, int target) {
        for(int i = 0; i < n; i++)
        {
            if(A[i] == target)
                return i;
        }
        return -1;
    }
};

使用分治法实现的方案：

class Solution {
public:
    int mySearch(int A[], int n, int target, int l, int r)
    {
        if(l > r)
            return -1;
        int mid = (l + r) / 2;
        bool isLeft;
        if(A[mid] == target)
            return mid;
        else if(A[l] <= A[mid])
        {
            if(A[l] <= target && A[mid] > target)
            {
                isLeft = true;
                int mid2 = (l + mid) / 2;
                if(target == A[mid2])
                    return mid2;
                else if(target < A[mid2])
                    return mySearch(A, n, target, l, mid2 - 1);
                else if(target > A[mid2])
                    return mySearch(A, n, target, mid2 + 1, mid - 1);
            }else{
                isLeft = false;
            }
            
        }else if(A[mid] <= A[r])
        {
            if(A[mid] < target && A[r] >= target)
            {
                isLeft = false;
                int mid2 = (mid + r) / 2;
                if(target == A[mid2])
                    return mid2;
                else if(target < A[mid2])
                    return mySearch(A, n, target, mid + 1, mid2 - 1);
                else if(target > A[mid2])
                    return mySearch(A, n, target, mid2 + 1, r);
            }else{
                isLeft = true;
            }
        }
        if(isLeft)
            return mySearch(A, n, target, l, mid - 1);
        else
            return mySearch(A, n, target, mid + 1, r);
    }
    
    int search(int A[], int n, int target) {
        return mySearch(A, n, target, 0, n - 1);
    }
};