二分查找-有重复数和无重复数

1、适用于无重复数的版本

二分查找要求数组有序，时间复杂度为O(lgn)。适用于无重复数的版本如下：

#include<iostream>
using namespace std;

int biSearch(int a[], int n, int key)
{//非递归
    int low=0, high=n-1, mid;
    while(low<=high)
    {
        mid=low+(high-low)/2;
        if(a[mid]==key)
            return mid;
        else if(a[mid]>key)
            high=mid-1;
        else
            low=mid+1;
    }
    return -1;
}
int biSearchRecursion(int a[], int low, int high, int key)
{//递归
    if(low>high)
        return -1;
    int mid=low+(high-low)/2;
    if(a[mid]==key)
        return mid;
    else if(a[mid]>key)
        return biSearchRecursion(a, low, mid-1, key);
    else
        return biSearchRecursion(a, mid+1, high, key);
}
int main()
{
    int a[]={1,2,3,4,5,6};
    int n=sizeof(a)/sizeof(a[0]);
    cout<<biSearch(a, n, 3)<<endl;
    cout<<biSearchRecursion(a,0,n-1,2)<<endl;
    return 0;
}

如上所示代码都是适用于无重复数的数组，对于有重复数key的数组，给出的位置则是其中的一个，而不是精确定位到上界或者下界，那么这时需要做些改变。

2、适用于有重复数的版本

1.STL版本：lower_bound()，upper_bound()

ForwardIter lower_bound(ForwardIter first, ForwardIter 
last,const _Tp& val)算法返回一个非递减序列[first, last)中的第一
个大于等于值val的位置。

ForwardIter upper_bound(ForwardIter first, ForwardIter 
last, const _Tp& val)算法返回一个非递减序列[first, last)中第一
个大于val的位置。

如果元素只出现一次，那么lower_bound()找到这个元素的地址，但是upper_bound()找到的却是它的下一个；

如果相同元素出现了多次，那么lower_bound()找到了第一个所找元素的地址，但是upper_bound()找到的却是最后一个元素的下一个元素的地址。前闭后开！！！！

#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
    int a[]={1,2,3,3,3,4,5,6};
    int n=sizeof(a)/sizeof(a[0]);
    //cout<<biSearch(a, n, 3)<<endl;
    //cout<<biSearchRecursion(a,0,n-1,2)<<endl;
    cout<<lower_bound(a,a+n,3)<<endl;//地址：0x28feec
    cout<<upper_bound(a,a+n,3)<<endl;//地址：0x28fef8
    减去首地址，就找到了下标位置
    cout<<lower_bound(a,a+n,3)-a<<endl;//2，第一个出现的位置
    cout<<upper_bound(a,a+n,3)-a<<endl;//5!!!最后一个的下一位置
    return 0;
}

2.

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int n=data.size();
        if(n==0) return 0;
        int first=GetFirstK(data,k,0,n-1);
        int last=GetLastK(data,k,0,n-1);
        int num=0;
        if(first>-1 && last>-1)
            num = last-first+1;
        return num;
    }
    int GetFirstK(vector<int> &a, int k, int start, int end)
    {//至少包含一个k则返回第一个的下标
        if(start > end) return -1;//不包含k则返回-1
        int mid=start + (end-start)/2;
        if(a[mid]==k){
            if((mid>0&&a[mid-1]!=k) || mid==0)
                return mid;
            else
                end=mid-1;
        }
        else if(a[mid]<k)
            start=mid+1;
        else
            end=mid-1;
        return GetFirstK(a, k, start, end);
    }
    int GetLastK(vector<int> &a, int k, int start, int end)
    {//至少包含一个k则返回最后一个的下标
        if(start > end) return -1;//不包含k则返回-1
        int mid=start + (end-start)/2;
        if(a[mid]==k){
            if((mid<a.size()-1&&a[mid+1]!=k) || mid==a.size()-1)
                return mid;
            else
                start=mid+1;
        }
        else if(a[mid]<k)
            start=mid+1;
        else
            end=mid-1;
        return GetLastK(a, k, start, end);
    }

};