二分查找
正常实现
题解
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)。
有两种计算中值 m 的方式：
- m = (l + h) / 2
- m = l + (h - l) / 2
l + h 可能出现加法溢出，也就是说加法的结果大于整型能够表示的范围。但是 l 和 h 都为正数，因此 h - l 不会出现加法溢出问题。所以，最好使用第二种计算法方法。
我感觉这里l,h最终都会扫到一个点上，即某一时刻l=h=m，只有L=h时，m才会=l=h，所以循环终止条件为l<=h
744 寻找比目标字母大的最小字母
题目描述
给定一个只包含小写字母的有序数组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"
题解
class Solution:
def nextGreatestLetter(self, letters: List[str], target: str) -> str:
l,r = 0,len(letters)-1
if target<letters[l] or target>=letters[r]:
return letters[l]
while l<=r:
m = l + (r-l)//2
if target>=letters[m]:
l = m + 1
else:
r = m - 1
return letters[l]
这里l<=r，不能l<r，例如
输入：
["c","f","j"]
"c"
输出：
"c"
预期：
"f"
因为target < letters[m]时，r=m-1会出现r指到l的情况，这时还需一次循环。
我的思路时将所有情况分为三种：
- target<letters[l]
- target>=letters[r]
- letters[l]<=target<letters[r]
因为1,2种结果一样就归为一类，上面代码主要讨论第三种。
最终l是要比m前一位，所以输出l
278第一个错误的版本
题目描述
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例
给定 n = 5，并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
题解(python)
# The isBadVersion API is already defined for you.
# @param version, an integer
# @return a bool
# def isBadVersion(version):
class Solution:
def firstBadVersion(self, n):
"""
:type n: int
:rtype: int
"""
l,r = 1,n
while l<=r:
m = l+(r-l)//2
if isBadVersion(m):
r = m-1
else:
l = m+1
return l
总结
做了这么几道题，有点感觉。例如上面这道，或者之前的最终情况我们可以想象成三个元素的区间，[a(0),a(1),a(2)]，l=0,r=2。讨论一下第一轮m=1时，a(1)是否符合条件，就容易判断边界条件了。
我感觉当l<=r时，也就是考虑l=r时，也就是最后肯定会出现l=r，这时候上面这个例子中，m=l=r, 此时若m处是满足条件的，那么r=m-1，r就是最后错误版本之前正确的版本，l=m最后错误版本。若m处不满足条件，那么l=m+1，l就是最后错误版本,此时m=r是最后正确版本。
也就是说，当l<=r时，这种情况下l如果等于m-1，那么l最后会指向最后满足，我们设定条件的位置，这道题的条件即是否是错误版本，r则会指向其之前一位。