摘要：在排好序的單詞列表中查找某個單詞優化和的初始化，從開始，這樣避免只有時的優化減少了內存溢出的風險優化循環時，。

迭代法（Iterative Method），簡單來說，其實就是不斷地用舊的變量值，遞推計算新的變量值。循環。

求數值的精確/近似解

二分法（Bisection method）

牛頓迭代法（Newton’s method）

在一定范圍內查找目標值

二分查找

機器學習中的迭代算法

K-均值算法（K-means clustering）

PageRank 的馬爾科夫鏈（Markov chain）

梯度下降法（Gradient descent）

求方程的精確/近似解

二分法

#"""計算某個給定正整數 n（n>1）的平方根，如果不使用編程語言"""
# delta_threshold:允許的誤差的閾值
# max_try：最大嘗試次數
def get_squre_root(n,delta_threshold=0.000000000000001,max_try=1000):
    if n <= 1:
        return -1
    min = 1.0
    n = float(n)
    max = n
    mid = (max+min)/2.0
    print(mid)
    for i in range(max_try):
        _n = mid * mid
        delta = _n-n
        if delta == 0:
            print("精確值")
            return mid
        
        abs_delta = abs(delta)
        if abs_delta <= delta_threshold:
            print("近似值")
            return mid
        else:
            if delta>0:
                max = mid
            else:
                min = mid
            mid = (max+min)/2.0
            print(mid)
    return min

get_squre_root(16)

牛頓迭代法
之后補充

查找匹配記錄
快速查找記錄，除了用字典，還可以用著名的 二分查找法（前提是有序）。這也是迭代逼近的典型案例。

二分查找，第一版

#在排好序的單詞列表中查找某個單詞
#@ param words_list,target_word
#@ return bool
def search(words_list,target_word):
    if not words_list:
        return False
    
    min = 1
    max = len(words_list)
    while True:
        mid = (max + min)/2
        mid_word = words_list[mid]
        if target_word == mid_word:
            print(mid)
            return True
        elif target_word > mid_word:
            min = mid
        else:
            max = mid

        if max <= min:
            return False

    return False
# words_list = ["i","love","my","wife","than","myself"s","body","."]
words_list = ["e"]
words_list = sorted(words_list)
print(words_list)
print(search(words_list,"i"))

二分查找，改完bug后，第二版

#在排好序的單詞列表中查找某個單詞
#@ param words_list,target_word
#@ return bool
# 優化1: min和max的初始化，從0開始，這樣避免只有len(list)=1時的bug
# 優化2: mid = min + (max - min)/2 ,減少了內存溢出的風險
def search(words_list,target_word):
    if not words_list:
        return False
    
    min = 0
    max = len(words_list) - 1
    while True:
        mid = min + (max - min)/2
        mid_word = words_list[mid]
        if target_word == mid_word:
            print(mid)
            return True
        elif target_word > mid_word:
            min = mid
        else:
            max = mid

        if max <= min:
            return False

    return False
words_list = ["i","love","my","wife","than","myself"s","body","."]
# words_list = ["e"]
words_list = sorted(words_list)
print(words_list)
print(search(words_list,"i"))

二分查找，再改bug后，第三版（應該沒bug了吧。。）

#在排好序的單詞列表中查找某個單詞
#@ param words_list,target_word
#@ return bool
# 優化1: min和max的初始化，從0開始，這樣避免只有len(list)=1時的bug
# 優化2: mid = min + (max - min)/2 ,減少了內存溢出的風險
# 優化3: 循環時，min = mid + 1。和max = mid - 1。減少重復檢查邊界
# 優化4: 跳出循環的條件改為max < min，避免最后一步出現max=min=target的潛在bug
def search(words_list,target_word):
    if not words_list:
        return False
    
    min = 0
    max = len(words_list) - 1
    while True:
        mid = min + (max - min)/2
        mid_word = words_list[mid]
        if target_word == mid_word:
            print(mid)
            return True
        elif target_word > mid_word:
            min = mid + 1
        else:
            max = mid - 1

        if max < min:
            print(max)
            return False

    return False
words_list = ["i","love","my","wife","than","myself"s","body","."]
# words_list = ["e"]
words_list = sorted(words_list)
print(words_list)
print(search(words_list,"i"))

迭代法的特點是“分而治之”，不斷重復一個相似的行為，一步步地縮小目標范圍。計算機很適合處理這種重復的工作，而人類并不擅長，所以有時候不敏感。在編程的時候，可以特意留意這一差異。