二分查找的几个变种（Java代码实现）

二分查找是一种比较普遍的查找方法，面试的时候也会经常问道，但稍微有点档次的公司都不会直接问二分查找的递归和非递归实现（因为太没技术含量了），所以二分查找的几个变种，面试这还是需要熟悉的，下面介绍几种二分查找的变种：

  1.找s的最小位置

  

int BinarySearch(int a[],int l,int r)
{
    int m,ans=-1;
    while(l<=r)
    {
        m=(l+r)/2;
        //满足条件
        if(a[m]==s)
            ans=m,r=m-1;
        else
            l=m+1;
    }
    return ans;
}

  2.找s的最大位置

int BinarySearch(int a[],int l,int r)
{
    int m,ans=-1;
    while(l<=r)
    {
        m=(l+r)/2;
        //满足条件
        if(a[m]==s)
            ans=m,l=m+1;
        else
            r=m-1;
    }
    return ans;
}

3.找小于等于s的最大位置

int BinarySearch(int a[],int l,int r,int key)
{
    int m,ans=-1;
    while(l<=r)
    {
        m=(l+r)/2;
        if(s>=a[m])
            ans=m,l=m+1;
        else
            r=m-1;
    }
    return ans;

OK，以上都是属于简单变形，一般的面试者都能应对，那接下来的变种就不是那么好看喽：

题目1：假设a和b都是升序的，分别有n1和n2个元素，求两个数组合并后第k大元素值。

下面，我们先来分析一个类似的问题，假设a和b都是升序的，分别有n1和n2个元素，求两个数组合并后第k大元素值。

分别取两个数组中间索引的数，a[x]和b[y]，比较两个数的大小：

if( a[x] <= a[y] )

——————————————————————————————————————————————————————————————

如果k <= x+y+1，则可以判断出b[y]以及b[y]后面的元素都可以排除在外，减小搜索规模。

如果k  > x+y+1，则可以判断出a数组的前半部分元素都不符合条件，减少a一半的搜索规模。

该算法利用了递归
的思想，结束条件是：

a中元素排除出去，则选择b中得第k大元素；

b中元素全部排除，选择a中第k大元素。

——————————————————————————————————————————————————————————————

代码实现：

int getMedian( int a[],int b[],int s1, int n1, int s2, int n2, int k ) {
    //x和y分别记录中间值的索引
    int x, y;

    x = (s1 + n1) / 2;        //记录a的中位数索引
    y = (s2 + n2) / 2;        //记录b的中位数索引

    if( s1 > n1 )
      return b[s2+k-1];
    if( s2 > n2 )
      return a[s1+k-1];

    if( a[x] <= b[y] ) {
        if( k <= (x-s1) + (y-s2) + 1 ) {
            return getMedian( s1, n1, s2, y-1, k );
        }
        else {
            return getMedian( x+1, n1, s2, n2, k-(x-s1)-1 );            
        }
    }
    else {
        if( k <= (x-s1)+(y-s2)+1 ) {
            return getMedian( s1, x-1, s2, n2, k );
        }
        else {
            return getMedian( s1, n1, y+1, n2, k-(y-s2)-1 );
        }
    }

    return 0;
}

题目2：找到轮转后的有序数组中第k小的数

对于普通的有序数组来说，这个问题是非常简单的，因为数组中的第k-1个数（即A[k-1]）就是所要找的数，时间复杂度是O(1)常量。但是对于轮转后的有序数组，在不知道轮转的偏移位置，我们就没有办法快速定位第K个数了。

不过我们还是可以通过二分查找法，在log(n)的时间内找到最小数的在数组中的位置，然后通过偏移来快速定位任意第k个数。当然此处还是假设数组中没有相同的数，原排列顺序是递增排列。

在轮转后的有序数组中查找最小数的算法如下：

	int findIndexOfMinVaule(int A[], int low, int high)
	{
	    if (low > high) return -1;
	    while (low < high) {
	        int mid = (low + high)/2;
	        if (A[mid] > A[high])
	            low = mid +1;
        else
	            high = mid;
	    }
	    return low;
	}

接着基于此结果进行偏移，再基于数组长度对偏移后的值取模，就可以找到第K个数在数组中的位置了：

	int findKthElement(int A[], int m, int k)
	{
                   if (k > m) 
                      return -1;
                  int base = findIndexOfMinVaule(A, 0, m-1);
                  int index = (base+k-1)%m;
                       return index; 
} 

当然，二分查找的变种肯定不止这些，我只是总结了几个经典的，以后会继续补充，其实算法万变不离其宗，只要你能吃透这个算法，任他怎么变你也依然能够谈笑风生。