二分查找
二分查找算法
描述
二分查找也称折半查找（Binary Search），它是一种效率非常高效的查找方法。但是折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
那它的效率有多高呢？还在给一个直观的数据做个展示吧，在一个1到2亿的个有充数组内查找一个给定值，使用二分查找需要多少次呢？最多也只需要28次。
##时间复杂度
二分查找的时间复杂非常的高，那高效到什么程序呢？
假设数据大小是n,每次查找都会缩小为原来的一半，即为除2操作，最坏情况下，直到查找区间缩小为空，才停止
被查找到的大小区间变化为
n,n/2,n/4,n/8,…,n/(2的k次方)
这是一个等比数列，n/(2的k次方)=1，可求得k=log2n，所以时间复杂度为O(logn)
logn是一种非常恐怖的数量数量级，即便n非常大，logn也很小，
比如2的30次方大约是10亿，在这10亿个数中使用二分查找，最多也就30次。
举个粟子
以“1,3,5,7,8,10,13”这组数据为例
public class BinarySearch {
/**
* 最简单的二分查找情况，在无重复的元素中去查找给定值
*
* @param data
* @param value
* @return
*/
public int search(int[] data, int value) {
if (null == data || data.length == 0) {
return -1;
}
int low = 0, mid, high = data.length - 1;
while (low <= high) {
mid = low + (high - low) / 2;
// 如果当前中间值等于组定值，则返回
if (data[mid] == value) {
return mid;
}
// 如果当前中间值大于组定值，说明在左区间查找
else if (data[mid] > value) {
high = mid - 1;
}
// 如果当前中间小于给定值，则说明在右区间查找
else {
low = mid + 1;
}
}
return -1;
}
}
二分查找的变体问题
变体1,查找每个值等于给定值的元素。
之前的数据中是不允许重复的，但在真实的数据中，数据是会存在重复的。
现在的问题就变成了，在一个出现重复的元素中，查找给定值。
以数组“1,3,5,7,7,8,10,13”,查找第一个出现7的为例。
public class BinarySearchFirst {
/**
* 在一个重复的数组内，查找值等于给定值的元素，重复需要返回第一个
*
* @param data
* @param value
* @return
*/
public int search(int[] data, int value) {
if (null == data || data.length == 0) {
return -1;
}
int low = 0, mid, high = data.length - 1;
while (low <= high) {
mid = low + (high - low) / 2;
// 当查找到当前元素为给定元素
if (data[mid] == value) {
// 由于存在重复，需在检查是否为第一次出现
//为0，则肯定为首次出现，前一个元素不与当前元素相同，也说明首次出现
if (mid == 0 || data[mid - 1] != value) {
return mid;
}
// 非第一次出现，继续向左搜索
else {
high = mid - 1;
}
}
// 如果当前值中间值大于给定值，则在左区间查找
else if (data[mid] > value) {
high = mid - 1;
}
// 如果当前中间件小于给定值，则在右区间搜索
else {
low = mid + 1;
}
}
return -1;
}
}
变体2，查找最后一个值等于给定值的元素
以数组“1,3,5,7,7,8,10,13”,查找最后一个出现7的为例。
public class BinarySearchLast {
/**
* 在一个重复的数组内，查找最后一个值等于给定值的元素
*
* @param data
* @param value
* @return
*/
public int search(int[] data, int value) {
if (null == data || data.length == 0) {
return -1;
}
int low = 0, mid, high = data.length - 1;
while (low <= high) {
mid = low + (high - low) / 2;
// 1,如果区间中间件等于查找到的值
if (data[mid] == value) {
// 如果已经为最后值，说明为最后一个，
// 如果后一个元素与给定值不同，也说明为最后一个
if (data[mid] == high || data[mid + 1] != value) {
return mid;
}
// 如果非最后一个，则在右区间继续查找
else {
low = mid + 1;
}
}
// 如果区间中间值大于给定值，则说明需要继续在左区间查找
else if (data[mid] > value) {
high = mid - 1;
}
// 区间中间值小于给定值，则需要继续右区间中查找
else {
low = mid + 1;
}
}
return -1;
}
}
变体3，查找每个大于等于组定的元素
以数组“1,3,5,7,7,8,10,13”,查找最后一个出现7的为例。
public class BinarySearchEqualOrGreaterThan {
/**
* 查找第一个大于等于给定值的元素
*
* @param data
* @param value
* @return
*/
public int search(int[] data, int value) {
if (null == data || data.length == 0) {
return -1;
}
int low = 0, mid, high = data.length - 1;
while (low <= high) {
mid = low + (high - low) / 2;
// 当前区间中间值如果大于等于给定值
if (data[mid] >= value) {
// 如果为首元素或者前一个元素小于给定元素，则结束
if (mid == 0 || data[mid - 1] < value) {
return mid;
}
// 否则继续向左区间查找
else {
high = mid - 1;
}
}
// 如果当前区间中间值小于给定值，则在右区间查找
else {
low = mid + 1;
}
}
return -1;
}
}
变体4，查找最后一个小于等于给定值的元素
以数组“1,3,5,7,7,8,10,13”,查找最后一个出现7的为例。
public class BinarySearchEqualOrLessThan {
/**
* 查找最后一个小于等于给定值的元素
*
* @param data
* @param value
* @return
*/
public int search(int[] data, int value) {
if (null == data || data.length == 0) {
return -1;
}
int low = 0, mid, high = data.length - 1;
while (low <= high) {
mid = low + (high - low) / 2;
// 如果当前区间中间值小于等于给定值
if (data[mid] <= value) {
// 如果当前为最后一个，则直接返回
// 或者当前区间中间值的后一个元素大于给定元素，也返回
if (mid == high || data[mid + 1] > value) {
return mid;
}
// 否则继续在右区间继续查找
else {
low = mid + 1;
}
}
// 如果当前区间中间值大于给定值，则在左区间中查找
else {
high = mid - 1;
}
}
return -1;
}
}
关于二分查找的处理注意事项
二分查找算法写起来非常的烧脑，很容易因为细节处理不好而产生bug，
容易出现的错误：终点条件，区间上下界更新方法，返回值选择。