[LeetCode] Search for a Range 二分搜索

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,
Given [5, 7, 7, 8, 8, 10] and target value 8,
return [3, 4].

 

Hide Tags

  Array Binary Search

 

---

    这道是变形的二分搜索，写的有点冗余，没有很好的合并在一起。

　　方法是先二分搜索到 其中一个target， 然后分别二分搜索边界。

#include <vector>

#include <iostream>

using namespace std;



class Solution {

public:

    vector<int> searchRange(int A[], int n, int target) {

        vector<int > ret(2,-1);

        if(n<1) return ret;

        int mid = helpFun(A,0,n-1,target);

        if(mid !=-1){

            ret[0]=helpLeft(A,0,mid,target);

            ret[1]=helpRight(A,mid,n-1,target);

        }

        return ret;

    }



    int helpLeft(int *a,int lft, int rgt, int & tar)

    {

        if(a[lft]==tar) return lft;

        if(lft+1==rgt)  return rgt;

        int mid = (lft+rgt)/2;

        if(a[mid]==tar) return helpLeft(a,lft,mid,tar);

        else    return helpLeft(a,mid,rgt,tar);

    }



    int helpRight(int *a,int lft, int rgt, int & tar)

    {

        if(a[rgt]==tar) return rgt;

        if(lft+1==rgt)  return lft;

        int mid = (lft+rgt)/2;

        if(a[mid]==tar) return helpRight(a,mid,rgt,tar);

        else    return helpRight(a,lft,mid,tar);

    }



    int helpFun(int *a,int lft, int rgt, int & tar)

    {

        if(lft>rgt) return -1;

        if(lft == rgt){

            if(tar==a[lft]) return lft;

            return -1;

        }

        if(lft +1 == rgt){

            if(a[lft]==tar) return lft;

            if(a[rgt]==tar) return rgt;

            return -1;

        }

        int mid = (lft+rgt)/2;

        if(a[mid]==tar) return mid;

        if(a[mid]<tar)  return helpFun(a,mid+1,rgt,tar);

        else    return helpFun(a,lft,mid-1,tar);

    }

};



int main()

{

    int A[]={5, 7, 7, 8, 8, 10};

    Solution sol;

    vector<int > ret = sol.searchRange(A,sizeof(A)/sizeof(int),8);

    cout<<ret[0]<<ret[1]<<endl;

    return 0;

}

 

 

附件是一份集成的比较好的，思路是一样：

vector<int> searchRange(int a[], int n, int target) {

        vector<int> result(2,-1);

        int left = INT_MAX;

        int right = INT_MIN;

        binSearch(a, 0 , n-1, n, target, left, right);

        if (left != INT_MAX && right != INT_MIN) {

            result[0] = left;

            result[1] = right;

        }

        return result;

    }

    void binSearch(int a[], int l ,int h, int n, int target, int& left, int& right) {

        if (l > h) return;



        int m = (l+h)/2;

        if (a[m] > target) {

            binSearch(a,l,m-1,n,target, left, right);

        } else if (a[m] < target) {

            binSearch(a,m+1,h,n,target, left, right);

        } else {

            if (m < left) {

                left = m;

                if (m > 0 && a[m-1] == target) {

                    binSearch(a,l,m-1,n,target,left,m);

                }

            }

            if (m > right) {

                right  = m;

                if (m < n-1 && a[m+1] == target) {

                    binSearch(a,m+1,h,n,target,m,right);

                }

            }

        }

    }

View Code