数据结构与算法 --二分查找（十）
目录
一、二分查找思想
二分查找针对的是一个有序的数据集合，查找思想有点类似于分治思想。每次都通过跟区间的中间元素比对，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间缩小为0
举例
8，11，19，23，27，33，45，55，67，98
利用二分思想，每次都与区间的中间数据比对大小，缩小 查找的区间范围。如下图low和high表示待查找区间的下标，mid表示待查找区间的中间元素下标
二、时间复杂度
假设数据大小为n，每次查找后数据都会缩小为原来的一半 n, n/2, 2/4, 2/8, 2/2^k,最坏情况，知道查找区间被缩小为空，才停止
这是一个等比数列。当n/(2^k)=1时，k的值就是总共缩小的次数，也是查找的总次数。而每次缩小操作只涉及两个数据的大小比较，所以，经过k次区间缩小操作，时间复杂度就是O(k)。通过n/(2^k)=1，可求得k=log2n，所以时间复杂度是O(logn)。
这是一种极其高效的时间复杂度，有时甚至比O(1)的算法还要高效。为什么？
因为logn是一个非常“恐怖“的数量级，即便n非常大，对应的logn也很小。比如n等于2的32次方，也就是42亿，而logn才32。
三、二分查找的递归与非递归实现
二分查找循环实现：
public int bsearch(int[] a, int n, int value) {
int low = 0;
int high = n - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (a[mid] == value) {
return mid;
} else if (a[mid] < value) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
容易出错的地方：
1、循环退出条件
注意是low <= high ,而不是low < max。
例：1, 3, 4, 6, 7, 8 查找8；第一次8>4,low=mid+1=6；第二次8>6，low=mid+1=7；第三次8>7，low=mid+1=8，此时与high=low，需要再一次比较。所以一定要low<=high
2、mid取值
如果low和max较大的话，这样写mid=(low+high )/2，二者之和可能会溢出
改进 mid=low + (high-low)/2. 再改进mid=low+((high-low)>>1)，相对比除法运算，计算机处理位运算快得多
3、min和max的更新：
min = mid - 1，max = mid + 1，若直接写成min = mid，max=mid，就可能会发生死循环
例：high=3，low=3时，如果a[3]不等于value，就会导致死循环
二分查找递归实现
// 二分查找的递归实现
public int bsearch(int[] a, int n, int val) {
return bsearchInternally(a, 0, n - 1, val);
}
private int bsearchInternally(int[] a, int low, int high, int value) {
if (low > high) return -1;
int mid = low + ((high - low) >> 1);
if (a[mid] == value) {
return mid;
} else if (a[mid] < value) {
return bsearchInternally(a, mid+1, high, value);
} else {
return bsearchInternally(a, low, mid-1, value);
}
}
四、应用场景的局限性
1、二分查找依赖的是顺序表结构，即数组。
数组根据下标随机访问的时间复杂度式O(1)，而链表随机访问的时间复杂度式0(n)，所以数据使用链表存储，二分查找时间复杂度就会很高
2、二分查找针对的是有序数据，因此只能用在插入、删除操作不频繁，一次排序多次查找的场景中。
3、数据量太小不适合二分查找，与直接遍历相比效率提升不明显。但有一个例外，就是数据之间的比较操作非常费时，比如数组中存储的都是长度超过300的字符串，那这是还是尽量减少比较操作使用二分查找吧。
4、数据量太大也不是适合用二分查找，因为数组需要连续的空间，若数据量太大，往往找不到存储如此大规模数据的连续内存空间
问题：如何在1000万个整数中快速查找某个整数？
内存限制式100MB，每个数据大小式8字节，将数据存储在数组中，内存占用差不多80MB，可以全部加载进内存
然后使用快排进行升序排序，时间复杂度为O(nlogn)，然后在有序数组中使用二分查找算法进行查找，时间复杂度为O(logn)
五、常见的二分查找变形问题
数据都是从小到大排序为前提
1、查找第一个等于给定值的元素
//1.查找第一个等于给定值的元素
public static int search1(int a[],int n, int value) {
int low=0;
int high=n-1;
while(low<=high) {
int mid = low+((high-low)>>1);
if(a[mid] < value) {
low=mid+1;
}else if(a[mid] > value) {
high=mid-1;
}else {
//如果中间值是第一个元素，或者前面一个元素不等于要查找的值，那么a[mid]就是第一个等于该值的元素
if(mid==0 || a[mid-1]!=value) return mid;
high=mid-1;
}
}
return -1;
}2、查找最后值等于给定值的元素
//2.查找最后值等于给定值的元素
public static int search2(int a[],int n, int value) {
int low = 0;
int high = n-1;
while(low<=high) {
int mid = (low+high)/2;
if(a[mid] < value) {
low = mid+1;
}else if(a[mid] > value) {
high=mid-1;
}else {
//如果中间值是最后一个元素，或者中间值前面的元素不等于要查找的值，就返回该值
if(mid==n-1 || a[mid+1]!=value ) return mid;
low=mid+1;
}
}
return -1;
}3、查找第一个大于等于给定值的元素
// 3.查找第一个大于等于给定值的元素
public static int search3(int a[],int n, int value) {
int low = 0;
int high = n-1;
while(low<=high) {
int mid = (low+high)/2;
if(a[mid] >= value) {
//对于中间值大于给定值，我们先判断a[mid]是不是我们要找的第一个值大于等于定值
//如果该元素前面已经没有元素，或者该元素前面的元素小于该值，那么a[mid]就是我们要查找的值
if(mid==0 || a[mid-1] <value) return mid;
//如果a[mid-1]也大于要查找的值value,那说明要查找的元素在[low, mid-1]之间，所以high=mid-1
high=mid-1;
}else {
//如果要查找的值大于中间值，那么要查找的值肯定位于[mid+1,high]中
low=mid+1;
}
}
return -1;
}4、查找最后一个小于等于给定值的元素
//4.查找最后一个小于等于给定值的元素
public static int search(int a[],int n, int value) {
int low = 0;
int high = n-1;
while(low<=high) {
int mid = (low+high)/2;
if(a[mid] <= value) {
//对于中间值<=给定值，我们先判断a[mid]是不是我们要找的最后一个小于等于给定值的元素
//如果该元素是最后一个元素，或者该元素前面的元素大于该值，那么a[mid]就是我们要查找的值
if(mid==n-1 || a[mid+1] > value) return mid;
low=mid-1;
}else {
//如果要查找的值小于中间值，那么要查找的值肯定位于[0,mid-1]中
high=mid-1;
}
}
return -1;
}