参考: @CyC2018
正常实现
Input : [1,2,3,4,5]
key : 3
return the index : 2
public int binarySearch(int[] nums, int key) {
int l = 0, h = nums.length - 1;
while (l <= h) {
int m = l + (h - l) / 2;
if (nums[m] == key) {
return m;
} else if (nums[m] > key) {
h = m - 1;
} else {
l = m + 1;
}
}
return -1;
}
时间复杂度
二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
mid 计算
有两种计算中值 m 的方式：
- m = (l + h) / 2
- m = l + (h - l) / 2
l + h 可能出现加法溢出，也就是说加法的结果大于整型能够表示的范围。但是 l 和 h 都为正数，因此 h - l 不会出现加法溢出问题。所以，最好使用第二种计算法方法。
未成功查找的返回值
循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
- -1：以一个错误码表示没有查找到 key
- l：将 key 插入到 nums 中的正确位置
变种
二分查找可以有很多变种，实现变种要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
public int binarySearch(int[] nums, int key) {
int l = 0, h = nums.length - 1;
while (l < h) {
int m = l + (h - l) / 2;
if (nums[m] >= key) {
h = m;
} else {
l = m + 1;
}
}
return l;
}
该实现和正常实现有以下不同：
- h 的赋值表达式为 h = m
- 循环条件为 l < h
- 最后返回 l 而不是 -1
在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
在 h 的赋值表达式为 h = m 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
nums = {0, 1, 2}, key = 1
l m h
0 1 2 nums[m] >= key
0 0 1 nums[m] < key
1 1 1 nums[m] >= key
1 1 1 nums[m] >= key
...
当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
因此，对h和l的赋值总结如下：
h 的赋值和循环条件有关，当循环条件为 l <= h 时，h = mid - 1；当循环条件为 l < h 时，h = mid。解释如下：在循环条件为 l <= h 时，如果 h = mid，会出现循环无法退出的情况，例如 l = 1，h = 1，此时 mid 也等于 1，如果此时继续执行 h = mid，那么就会无限循环；在循环条件为 l < h，如果 h = mid - 1，会错误跳过查找的数，例如对于数组 [1,2,3]，要查找 1，最开始 l = 0，h = 2，mid = 1，判断 key < arr[mid] 执行 h = mid - 1 = 0，此时循环退出，直接把查找的数跳过了。
l 的赋值一般都为 l = mid + 1。
题目如下：
69.求开方（Easy）
441.摆硬币（Easy）
744.大于给定元素的最小元素（Easy）
278.第一个错误版本（Easy）
540.有序数组的Single Element（Medium）
153.旋转数组的最小数字（Medium）
34.查找区间（Medium）
具体题目实现：
69.求开方（Easy）
思路：
一个数 x 的开方 sqrt 一定在 0 ~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 ~ x 之间查找 sqrt。
对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
public int mySqrt(int x) {
if (x <= 1) {
return x;
}
int l = 1, h = x;
while (l <= h) {
int mid = l + (h - l) / 2;
int sqrt = x / mid;
if (sqrt == mid) {
return mid;
} else if (mid > sqrt) {
h = mid - 1;
} else {
l = mid + 1;
}
}
return h;
}
441.摆硬币（Easy）
有三种解法，分别是暴力解法、二分查找、数学解法，对应的时间复杂度分别是O(n)、O(logn)、O(1)。
1. 暴力解法
public int arrangeCoins(int n) {
if (n<1) {
return 0;
}
int rowNum = 1;
int remain = n - rowNum;
while (remain >= rowNum + 1) {
rowNum++;
remain = remain - rowNum; //更新剩余的值
}
return rowNum;
}
2. 二分查找
//方法二：二分查找，时间复杂度O(LogN).
//思路就是找到一个k，使得所有和刚好大于n，那么k-1就是答案。这个假设是基于行号k=n。
//但是这个方法在leetcode中超出时间限制了
public int arrangeCoins(int n) {
int l = 0, h = n;
while(l <= n ) {
int mid = l + (h - l) / 2;
long tmp = mid * (mid + 1)/2;
if(tmp == n) return mid;
else if(tmp < n) l = mid + 1;
else h = mid - 1;
}
return h;
}
3. 数学解法
//用解方程的公式，可以得到其正数解为：k = sqrt(2n + 1/4) - 1/2
//唯一的问题是这里2n + 1/4有可能会超出sqrt函数的参数范围
//查一下sqrt函数的参数范围吧，我也不清楚
public int arrangeCoins(int n) {
return (int)(Math.sqrt(2) * Math.sqrt(n + 0.125) - 0.5);
}
744.大于给定元素的最小元素（Easy）
题目描述：
给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
public char nextGreatestLetter(char[] letters, char target) {
int n = letters.length;
int l = 0, h = n - 1;
while(l <= h) {
int m = l + (h - l) / 2;
if (letters[m] <= target) {
l = m + 1;
}else {
h = m - 1;
}
}
return l < n ? letters[l] : letters[0];
//? :运算符的意思是如果？前面为真，就返回：左边的值，否则返回右边的值
}
278.第一个错误版本（Easy）
题目描述：
给定一个元素 n 代表有 [1, 2, ..., n] 版本，在第 x 位置开始出现错误版本，导致后面的版本都错误。可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
思路：
- 如果第m个版本出错，则表示第一个错误版本在[l,m]之间，则令h=m；否则第一个错误版本在[m+1,h]之间，令l=m+1;
- 因为h的赋值表达式为h=m，则循环条件就是 l
/* The isBadVersion API is defined in the parent class VersionControl.
boolean isBadVersion(int version); */
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int l = 1, h = n;
while(l < h) {
int mid = l + (h - l) / 2;
if (isBadVersion(mid)) {
h = mid;
}else {
l = mid + 1;
}
}
return l;
}
}
540.有序数组的Single Element（Medium）
题目描述：
一个有序数组只有一个数不出现两次，找出这个数。
输入: [1,1,2,3,3,4,4,8,8]
输出: 2
思路：
- 要求时间复杂度在O(1)~O(logn)，因此不能用遍历数组并进行异或（如果a、b两个值不相同，则异或结果为1。如果a、b两个值相同，异或结果为0）操作来求解，这么做的时间复杂度为O(n)。
- 令index为single element在数组中的位置。引入index之后，index之前与index之后数组成对的状态不同。如果m为偶数，并且m+1
- 从上面的规律可知，如果num[m] == num[m+1]，则index所在的位置是[m+2,h]，此时令l = m+2；如果num[m] != num[m+1]，则index所在的位置是[l,m]，此时令h = m。
- 因为h的赋值表达式为h = m，那么循环条件应为l < h。
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--; //保证m为偶数
}if (nums[m] == nums[m + 1]) {
l = m + 2;
}else {
h = m;
}
}
return nums[l];
}
153.旋转数组的最小数字（Medium）
题目描述：
假设数组中不存在重复元素，找到原有序数组经过旋转后得到的数组中的最小元素。
输入: [3,4,5,1,2]
输出: 1
思路：
只要mid位置上的元素比h位置上的元素小，就说明最小元素在m位置及m之前的位置，否则在m之后的位置
public int findMin(int[] nums) {
int l = 0, h = nums.length - 1;
while (l < h) {
int m = l + (h - l) / 2;
if (nums[m] <= nums[h]) {
h = m;
}else {
l = m + 1;
}
}
return nums[l];
}
以下题目保留：没看懂没想通
34.查找区间（Medium）
题目描述：
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。时间复杂度必须是 O(log n)。如果数组中不存在目标值，返回 [-1, -1]。
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
这个题先保留，目前处于看答案也懵逼的状态。。。。。
可以用二分查找找出第一个位置和最后一个位置，但是寻找的方法有所不同，需要实现两个二分查找。我们将寻找 target 最后一个位置，转换成寻找 target+1 第一个位置，再往前移动一个位置。这样我们只需要实现一个二分查找代码即可。
public int[] searchRange(int[] nums, int target) {
int first = findFirst(nums, target);
int last = findFirst(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)};
}
}
private int findFirst(int[] nums, int target) {
int l = 0, h = nums.length; // 注意 h 的初始值
while (l < h) {
int m = l + (h - l) / 2;
if (nums[m] >= target) {
h = m;
} else {
l = m + 1;
}
}
return l;
}
在寻找第一个位置的二分查找代码中，需要注意 h 的取值为 nums.length，而不是 nums.length - 1。先看以下示例：
nums = [2,2], target = 2
如果 h 的取值为 nums.length - 1，那么 last = findFirst(nums, target + 1) - 1 = 1 - 1 = 0。这是因为 findLeft 只会返回 [0, nums.length - 1] 范围的值，对于 findFirst([2,2], 3) ，我们希望返回 3 插入 nums 中的位置，也就是数组最后一个位置再往后一个位置，即 nums.length。所以我们需要将 h 取值为 nums.length，从而使得 findFirst返回的区间更大，能够覆盖 target 大于 nums 最后一个元素的情况。