二分法模板
链接：https://blog.csdn.net/qq_19446965/article/details/82184672
• 循环条件到底哪一个？
• start <= end
• start < end
• start + 1 < end
• 指针变换到底哪一个
• start = mid
• start = mid + 1
• start = mid - 1
弄不好就死循环，弄不好边界就失误
例：nums = [1,1], target = 1
使用start < end 会出现死循环
模板：
def bin_search(nums, target):
if not nums or target < nums[0] or target > nums[-1]:
return -1
left = 0
right = len(nums) - 1
while left + 1 < right: # 统一都用 <
mid = left + (right - left)//2
if target > nums[mid]: # 左边界> 右边界>=
left = mid # 永远不动，全文通用
elif target < nums[mid]:
right = mid # 永远不动，全文通用
else:
return mid # 等号可以合并到 < 或 > 也可以单独考虑
if nums[right] == target:
return right
if nums[left] == target:
return left
return -1 # 较小的left，较大的righ
总结：
1.判断是返回left，还是返回right
因为我们知道最后跳出while (left + 1< right)循环条件是left+ 1 == right。
最后left 和right一定是卡在"边界值"的左右两边
以数组{1, 2, 3, 3, 4,5}为例，
如果需要查找第一个等于或者小于3的元素下标，我们比较的key值是3，则最后left和right需要满足以下条件：
left——>2, right ——>3
我们比较的key值是3，所以此时我们需要返回left。
所以，最后只需要判断left或right是否等于target即可。
2.判断出比较符号
左边界附近都是>
右边界附近都>=
————————————————
模板讲解：https://blog.csdn.net/qq_19446965/article/details/82184672
模板套用练习题1：https://www.cnblogs.com/rnanprince/p/11743414.html
二分查找（倍增法）：https://blog.csdn.net/qq_19446965/article/details/102811021
模板套用练习题2：https://www.cnblogs.com/rnanprince/p/11761940.html
倍增:
二分查找（倍增法）：https://blog.csdn.net/qq_19446965/article/details/102811021
首先特判一下首个元素. 然后设定 idx = 0 为查找的下标, jump = 1 为向后跳跃的长度.
每次循环将 idx 向后移动 jump 个元素, 并将 jump 翻倍. 而如果移动后的位置不小于 target, 则 jump 缩小至一半.
即我们在保证每次跳跃后的 idx 的位置都小于target的前提下, 倍增式地跳跃, 以此保证 O(logn) 的时间复杂度.
循环终止的条件就是 jump == 0, 就是说, 这时 idx + 1 的位置以及不小于 target 了 (此时idx位置的仍然是小于target)
也就是说, 到最后idx指向的元素是: 最大的小于target的元素. 返回答案前判断一下 idx + 1 是否 target 即可.
————————————————
辗转相除法：
又名欧几里德算法， 是求最大公约数的一种方法。它的具体做法是：用较大的数除以较小的数，再用除数除以出现的余数（第一余数），再用第一余数除以出现的余数（第二余数），如此反复，直到最后余数是0为止。如果是求两个数的最大公约数，那么最后的除数就是这两个数的最大公约数。
def gcd(big, small):
if small != 0:
return gcd(small, big % small)
else:
return big
————————————————
快速幂算法
计算x的n次方， 即计算x^n。
由公式可知： x^n = x^{n/2} * x^{n/2}。
如果我们求得x^{n/2}， 则可以O(1)求出x^n, 而不需要再去循环剩下的n/2次。
以此类推，若求得x^{n/4}， 则可以O(1)求出x^{n/2}
。。。。
因此一个原本O(n)的问题，我们可以用O(logn)复杂度的算法来解决。
递归版本的快速幂算法
def power(x, n):
if n == 0:
return 1
if n % 2 == 0:
tmp = power(x, n // 2)
return tmp * tmp
else:
tmp = power(x, n // 2)
return tmp * tmp * x
非递归版本
def power(x, n):
ans = 1
base = x
while n > 0:
if n % 2 == 1:
ans *= base
base *= base
n = n // 2
return ans
————————————————
斐波那契数列-求第n项
非递归版
def fibonacci(n):
res = [0, 1]
while len(res) <= n:
res.append(res[-1]+res[-2])
return res[n]
递归版
def fibonacci(n):
if n == 0:
return 0
if n == 1 or n == 2:
return 1
return fibonacci(n - 1) + fibonacci(n - 2)
题型参见：https://www.cnblogs.com/rnanprince/p/11600976.html