这里引用一个Grandyang大佬的关于二分查找的文章：www.cnblogs.com/grandyang/p…
69. x 的平方根(Easy)
实现 int sqrt(int x) 函数。计算并返回 x 的平方根，其中 x 是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
题解：x的平方根一定在[0,x]之间，并且sqrt == x / sqrt。所以可以使用二分查找在[0,x]之间查找，二分查找需要特别注意循环条件及返回值，例如x=8的情况下，平方根为2.828，返回的应该是2，而不是3，
class Solution {
public int mySqrt(int x) {
if (x <= 1) {
return x;
}
int left = 1;
int right = x;
while (left <= right) {
int mid = left + (right - left) / 2;
// 乘法会导致数据溢出，所以不能使用乘法
// tmp = mid * mid;
int sqrt = x / mid;
if (sqrt == mid) {
return mid;
} else if (mid > sqrt) {
right = mid - 1;
} else if (mid < sqrt) {
left = mid + 1;
}
}
return right;
}
}
744. 寻找比目标字母大的最小字母(Easy)
给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。
数组里字母的顺序是循环的。举个例子，如果目标字母target = 'z' 并且有序数组为 letters = ['a', 'b']，则答案返回 'a'。
示例:
输入:
letters = ["c", "f", "j"]
target = "a"
输出: "c"
输入:
letters = ["c", "f", "j"]
target = "c"
输出: "f"
输入:
letters = ["c", "f", "j"]
target = "d"
输出: "f"
输入:
letters = ["c", "f", "j"]
target = "g"
输出: "j"
输入:
letters = ["c", "f", "j"]
target = "j"
输出: "c"
输入:
letters = ["c", "f", "j"] target = "k" 输出: "c"
注:
letters长度范围在[2, 10000]区间内。
letters 仅由小写字母组成，最少包含两个不同的字母。
目标字母target 是一个小写字母。
题解：题目说数组是循环的，那么如果target >= letters[letters.length - 1]，就返回数组中的第一个元素，数组至少有两个元素，
class Solution {
public char nextGreatestLetter(char[] letters, char target) {
//target 大于等于 数组最后一个元素
if (target >= letters[letters.length - 1]){
return letters[0];
}
//否则二分查找（模板）
int l = 0;
int r = letters.length;
while(l < r){
int m = l + (r - l) / 2;
//当前值小于或等于目标值，将l更新为m + 1，因为要找的是大于target的第一个元素
if(letters[m] <= target){
l = m + 1;
}else{
r = m;
}
}
return r;
}
}
540. 有序数组中的单一元素(Medium)
给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。
示例 1:
输入: [1,1,2,3,3,4,4,8,8]
输出: 2
示例 2:
输入: [3,3,7,7,10,11,11]
输出: 10
注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。
题解：
- 如果不考虑时间复杂度，可以使用一个HashMap来存储数字及其出现的次数；或者使用异或运算，遍历一遍数组就可以得到答案。
- 如果在 O(log n)时间复杂度和O(1)空间复杂度，那么上述方法就不可行，首先仔细分析题目：整数，有序，只有一个数出现一次。那么可以想到的 O(log n)时间复杂度方法是是二分搜索：观察以上两个示例可得，如果mid左右两边为偶数，singleNum出现在与nums[mid]相等的那一边，因为偶数减一为奇数；如果mid左右为奇数，就相反。
class Solution {
public int singleNonDuplicate(int[] nums) {
int left = 0;
int right = nums.length - 1;
int len = nums.length;
//二分搜索
while (left < right){
int mid = left + (right - left) / 2;
//如果nums[mid] == nums[mid + 1]
if (nums[mid] == nums[mid + 1]){
//如果左右两边为偶数，那么single出现在右边
if ((len - mid - 1) % 2 == 0){
left = mid + 1;
}else {
//如果左右两边为奇数，那么在左边
right = mid;
}
}else if (nums[mid] == nums[mid - 1]){
//如果左右两边为偶数，那么single出现在左边
if ((len - mid - 1) % 2 == 0){
right = mid - 2;
}else {
//如果左右两边为奇数，那么在左边
left = mid + 1;
}
}else {
return nums[mid];
}
}
return nums[left];
}
}
优化后的代码
//当mid在偶数位的时候，哪边跟nums[mid]相等，single就在哪边
public int singleNonDuplicate(int[] nums) {
int l = 0, h = nums.length - 1;
while (l < h) {
int m = l + (h - l) / 2;
if (m % 2 == 1) {
m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
}
if (nums[m] == nums[m + 1]) {
l = m + 2;
} else {
h = m;
}
}
return nums[l];
}
278.第一个错误的版本(Easy)
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例:
给定 n = 5，并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
题解：
- 题意说：每个版本都是基于之前的版本开发的，可以想到这是有序的，所以可以使用二分搜索，mid如果是出错的，那么mid之后都是出错的，往左边查找
- 如果不考虑时间复杂度可以使用遍历数组的方式。
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int left = 1;
int right = n;
while(left < right){
int mid = left + (right - left) / 2;
//mid如果是出错的，那么mid之后都是出错的,往左边查找
if(isBadVersion(mid)){
right = mid;
}else{
left = mid + 1;
}
}
return left;
}
}
153. 寻找旋转排序数组中的最小值(Medium)
假设按照升序排序的数组在预先未知的某个点上进行了旋转。 ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 请找出其中最小的元素。 你可以假设数组中不存在重复元素。
示例 1:
输入: [3,4,5,1,2]
输出: 1
示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0
如果不考虑时间复杂度，直接遍历数组，比较前后元素即可找到最小值。
解法一：一个数组是有序的，很容易想到二分搜索，首先明确一个点：一个有序数组的后面元素肯定比前面的大，旋转的那部分也符合这个特征。
- 如果一个数组没有旋转，那么第一个元素即是最小值；
- 如果数组旋转了，那么有如下几种情况
2.1 如果nums[mid] > nums[mid + 1]，则最小值是nums[mid + 1]；
2.2 如果nums[mid] < nums[mid - 1]，则最小值是nums[mid]；
2.3 如果nums[mid] < nums[right]，那么往左边找，否则往右边找
class Solution {
public int findMin(int[] nums) {
//只有一个元素，返回本身
if (nums.length == 1) {
return nums[0];
}
int left = 0;
int right = nums.length - 1;
//数组没有旋转，那么第一个元素即是最小值
if (nums[0] < nums[nums.length - 1]) {
return nums[0];
}
//数组旋转了，二分查找
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] > nums[mid + 1]) {
return nums[mid + 1];
}
if (nums[mid] < nums[mid - 1]) {
return nums[mid];
}
if (nums[mid] < nums[right]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return -1;
}
}
34. 在排序数组中查找元素的第一个和最后一个位置（Medium）
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。 你的算法时间复杂度必须是 O(log n) 级别。如果数组中不存在目标值，返回 [-1, -1]。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
不考虑时间复杂度的话直接遍历即可得出答案，但是题目限制了时间复杂度，这种方法就不予考虑
题解：仔细分析题目，可以发现数组是升序排列的，需要找出目标值在数组中的开始位置和结束位置，不难想到可以使用二分查找，先判断target是否大于数组中end或者小于start，如果是就返回{-1,-1}，接着用两个二分查找，分别找到开始和结束位置
class Solution {
public int[] searchRange(int[] nums, int target) {
int first = find(nums, target);
int last = find(nums, target + 1) - 1;
if (first == nums.length || nums[first] != target) {
return new int[]{-1, -1};
} else {
return new int[]{first, Math.max(first, last)};
}
}
//用二分查找找出 大于target 的第一个元素
private int find(int[] nums, int target){
int left = 0;
int right = nums.length;
while (left < right){
int mid = left + (right - left) / 2;
if (nums[mid] < target){
left = mid + 1;
}else {
right = mid;
}
}
return left;
}
}
