二分查找的相关内容（详细）

二分查找是学习算法的必修之课，然而二分查找有多种实现方式，根据题目要求可以使用不同的方法来实现，如果没有理清楚这些方法之间的差别，在实现算法时很容易乱了针脚，我将二分查找的相关方法介绍如下：

简单实现二分查找的两种方法

我们先从简单入手，在一个单调递增数组（无重复值）中查找target值。
二分查找一般有两种实现方法，分别时左闭右闭和左闭右开，两种方法都能够找到target值，下面我们具体来看一下这两种方法：

// 左闭右闭
//nums是数组，size是数组的大小，target是需要查找的值
// 本题通过数组下标来实现的，在有些题目中通过给定最大最小值分别对应left和right即可
int search(int nums[], int size, int target) 
{
    int left = 0;
    int right = size - 1;	// 定义了target在左闭右闭的区间内，[left, right]
    while (left <= right) {	//当left == right时，区间[left, right]仍然有效
        int middle = left + ((right - left) / 2);//等同于 (left + right) / 2，防止溢出
        if (nums[middle] > target) {
            right = middle - 1;	//target在左区间，所以[left, middle - 1]
        } else if (nums[middle] < target) {
            left = middle + 1;	//target在右区间，所以[middle + 1, right]
        } else {	//既不在左边，也不在右边，那就是找到答案了
            return middle;
        }
    }
    //没有找到目标值
    return -1;
}


// 左闭右开
int search(int nums[], int size, int target)
{
	int left = 0;
	int right = size; //定义target在左闭右开的区间里，即[left, right)
	while (left < right) {	//因为left = right的时候，在[left, right)区间上无意义
		int middle = left + ((right - left) / 2);
		if (nums[middle] > target) {
			right = middle; //target 在左区间，在[left, middle)中 
		} else if (nums[middle] < target) {
			left = middle + 1;
		} else {
			return middle; 
		}
	} 
    // 没找到就返回-1
	return -1;
}

// 左闭右开优化版,将相等的情况加到right的修改中，在循环结束后return left
int search(int nums[], int size, int target)
{
	int left = 0;
	int right = size; //定义target在左闭右开的区间里，即[left, right)
	while (left < right) {	//因为left = right的时候，在[left, right)区间上无意义
		int middle = left + ((right - left) / 2);
		if (nums[middle] < target) {
			left = middle + 1;
		} else {
			right = middle; //target 在左区间，在[left, middle)中 
		}
	} 
	return left;
}

TreeSet中floor和ceiling函数

floor(E e) 方法返回在这个集合中小于或者等于给定元素的最大元素，如果不存在这样的元素,返回null.
ceiling(E e) 方法返回在这个集合中大于或者等于给定元素的最小元素，如果不存在这样的元素,返回null.

public class TreeSetDemo {
   public static void main(String[] args) {
     // creating a TreeSet 
     TreeSet <Integer>treeset = new TreeSet<Integer>();
     
     // adding in the tree set
     treeset.add(23);
     treeset.add(25);
     treeset.add(35);
     treeset.add(40);
     
     // getting the floor value for 13
     System.out.println(treeset.floor(26));   	// 25
     System.out.println(treeset.ceiling(33)); 	// 35
   }    
} 

C++中的lower_bound和upper_bound

底层实现主要是通过二分查找来进行，所以认为数组是单调递增，如果查找数组不是单调数组，最后结果可能不符合期望值。还要注意返回值是数组的下标（指针）。
lower_bound（a, a + a.size(), num）:返回数组中大于等于num的下标
upper_bound （a, a + a.size(), num）:返回数组中大于num的下标

#include<bits/stdc++.h>
using namespace std;
int main() {
  int a[] = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4};
 
  cout << (lower_bound(a, a + 12, 4) - a) << endl; //输出 9
  cout << (upper_bound(a, a + 12, 4) - a) << endl; //输出 12
  cout << (lower_bound(a, a + 12, 1) - a) << endl; //输出 0
  cout << (upper_bound(a, a + 12, 1) - a) << endl; //输出 3
  cout << (lower_bound(a, a + 12, 3) - a) << endl; //输出 6
  cout << (upper_bound(a, a + 12, 3) - a) << endl; //输出 9
  cout << (lower_bound(a, a + 12, 5) - a) << endl; //输出 12
  cout << (upper_bound(a, a + 12, 5) - a) << endl; //输出 12
  cout << (lower_bound(a, a + 12, 0) - a) << endl; //输出 0
  cout << (upper_bound(a, a + 12, 0) - a) << endl; //输出 0
 
  return 0;
}

下面我们来看一下C++中lower_bound和upper_bound的底层实现：

// lower_bound,其实就是上方简单方法中的左闭右开方法
int myLowerBound(vector<int> &data, int k)
{
	int start = 0;
	int last = data.size();
	while (start < last) {
		int mid = (start + last) / 2;
		if (data[mid] < k) {
			start = mid + 1;
		} else {
			last = mid;
		}
	}
	return start;
}

// upper_bound,将相等的情况加到了left的修改中，从而达到upper的效果
int myUpperBound(vector<int> &data, int k)
{
	int start = 0;
	int last = data.size();
	while (start < last) {
		int mid = (start + last) / 2;
		if (data[mid] <= k) {
			start = mid + 1;
		} else {
			last = mid;
		}
	}
	return start;
}

Python中的二分查找bisect函数

bisect 函数其实是 bisect_right 函数的别名，后者还有个姊妹函数叫bisect_left。
bisect_left函数是新元素会被放置于它相等的元素的前面，而 bisect_right返回的则是跟它相等的元素之后的位置。

import bisect

a = [0, 4, 5, 7, 19, 25]

# 这个返回3，是因为bisect会把新的元素放在相等元素后面即 2 + 1 = 3
a1 = bisect.bisect(a, 5)

# 这个返回2，是因为bisect_left会把新的元素放在相等元素前面即原来值5的索引位置2
a2 = bisect.bisect_left(a, 5)

print(a1, a2) # 3, 2

这里需要注意数组a仍然需要为有序数组