二分查找及其扩展循环查找及二维查找

1.一般二分查找

    N个数字已经从大到小排列，给定一个数P，P是否存在于这N个数中？在怎样的策略下，使得最坏的情况下，需要比较的次数最少？为什么？
    顺序查找,平均需要比较（N+1）/2次，最多需要比较N次。
    如果二分查找，则最多需要比较log(n)+1 次。
    如果排列有规律，采用哈希表，则一次查表就可以找到结果。但Hash表要求的空间复杂度是O(N)的。

二分查找的代码如下：

int binarysearch(int *srclist,int num, int begin, int end)
{
	int mid = (begin + end)/2;

	if (begin > end)
	{
		return -1;
	}

	if (num == *(srclist+mid))
	{
		return mid;
	}
	else if (num > *(srclist +mid))
	{
		binarysearch(srclist,num,mid+1,end);
	}
	else
	{
		binarysearch(srclist,num,0,mid-1);
	}	 
}

2.循环二分查找

       二分查找的变体，二分查找的输入是已经排好序的序列，此时的输入方法见手写代码-二分查找，其一个变体为，如果输入为循环升序数组(如678912345 )时，应当如何调整？( 百度面试)

      仍然采用二分查找的思想进行，首先查找中值，如果与查找值相同，则返回。否则比较中值与左右值的大小，如果小于右值，说明右边是排好序的，如果查找值大于中值，小于右值，则一定在左半部分，否则在右半部分。依次类推即可。代码如下：

int  binary_cycle_search(int *a, int ele,int low, int high)
{
		if (low>=high)
		{
			return -1;
		}
		int mid =(low+high)/2;
		if (a[mid]==ele)
		{
			return mid;
		}
	
		if (a[mid]<=a[high])//右半部分已排序
		{
			if (a[mid]<ele&&ele<=a[high])
			{
				return binary_cycle_search(a,ele,mid+1,high);
			}
		else
			{
				return binary_cycle_search(a,ele,low,mid-1);
			}
		}
		else//左半部分已排序
		{
			if (ele>=a[0]&&ele<a[mid])
			{
				return binary_cycle_search(a,ele,low,mid-1);
			}
		else
			{
				return binary_cycle_search(a,ele,mid+1,high);
			}
		}
}

3.二维二分查找

     另外的一个变体即，对二维排序数组(行和列均排好序的数组)进行查找某个元素( 创新工场2014bupt考试)

     此部分来自： http://www.docin.com/p-470870588.html

     此时可以首先将目标值与左上角或右下角值相比较，如果其小于左上角值或大于右上角值，则返回-1，否则开始在数组内部查找。因为二维排序数组，可以看成是一个沿对角线方向增长的结构，所以可以根据对角线进行查询。找到对角线上的一个元素，使得这个元素小于待查找的key，并且下一元素大于待查找的key，那么只要在这个元素的左下角矩阵和右上角矩阵递归继续对角线查找就可以了。

                             

    例如上图例子里查找7，只要找到对角线的元素4，然后递归查找红圈的矩阵就可以了，左上角矩阵最大值4<7，右下角矩阵最小值10>7，无需查找了，但是此题并没有告诉我们原始矩阵是n*n的，这是比较麻烦的地方，不过思路是一样的，无非不能用对角线查找这样简单的办法了，假设m*n的矩阵，对角线查找的办法改进为i = (m1+m2)/2，j = (n1+n2)/2 进行查找就可以了，(m1,n1)为矩阵最左上角元素下标，(m2,n2)为最右下角元素下标

假设查找17，第一次比较10，然后比较25，然后比较13，返回元素13，这时候再递归查找13左下角的矩阵和右上角的矩阵就可以了（红色椭圆部分）；如果是查找9，第一次比较10，然后比较4，然后比较6，返回元素6，这时候递归查找6左下角的矩阵和右上角矩阵（绿色椭圆部分）。

代码如下：

int binsearch(int value, int *a, int n, int m1, int n1, int m2, int n2)
{
        int begin_m1 = m1, begin_n1 = n1, end_m2 = m2, end_n2 = n2;
        int left_result = 0,  right_result = 0;
        int i = (m1+m2)/2, j = (n1+n2)/2;
        if (a == NULL)
                return 0;
        if (value < *(a+m1*n+n1) || value > *(a+m2*n+n2))
                return 0;
        else if (value == *(a+m1*n+n1) || value == *(a+m2*n+n2))
                return 1;
 
        while ((i!=m1 || j!=n1) && (i!=m2 || j!=n2)){
                 if ( value == *(a+i*n+j) )
                         return 1;
                 else if ( value < *(a+i*n+j) ){
                         m2 = i;
                         n2 = j;
                         i = (i+m1)/2;
                         j = (j+n1)/2;
                  }
                 else{
                         m1 = i;
                         n1 = j;
                         i = (i+m2)/2;
                         j = (j+n2)/2;
                 }
           }
          
           //search left & right
           if ( i<end_m2 )
                   left_result = binsearch(value, a, n, i+1, begin_n1, end_m2, j);
           if ( j<end_n2 )
                   right_result = binsearch(value, a, n, begin_m1, j+1, i, end_n2);
           if (left_result | right_result )
                   return 1;
           else
                   return 0;
}