Python算法——《算法圖解》筆記

算法目錄 

• 二分查找

•  大O表示法

• 選擇排序

• 遞歸

• 快速排序，分而治之（D&C）

•  散列表——字典

•  廣度優先搜索——BFS

• Dijkstra算法

• 貪婪算法

二分查找

# 要求list是有序表，num是要查找的數字
# 二分查找貌似只能查找數值表
def binary_search(list, num):
    low = 0
    high = len(list) - 1    # 因為python數組（列表）是從0開始索引的

    while low <= high:
        mid = (low + high)
        guess = list[mid]
        if guess == num:
            return "found it is " + str(mid)
        if guess > num:
            high = mid - 1
        else:
            low = mid + 1
    return "not found"

# python數組不同於matlab數組，python中間要用逗號隔開，而matlab不用
my_list = [1, 3, 5, 7, 9, 11, 13]
print(binary_search(my_list, 6))
print(binary_search(my_list, 9))

 大O表示法

1.   能夠比較操作數，表示算法運行時間的增速

2.   給出了一個時間的上限

3.   算法的速度並非時間，而是操作數的增速

4.   O(logn)——對數時間（二分查找）

5.   O(n)——線性時間（順序查找）

6.   O(n*logn)——快速排序

7.   O(n^2)——選擇排序

8.   O(n!)——旅行商問題的解決辦法

9.   常量並不會影響到大O表示法

 

 選擇排序

*   計算機內存如同一大堆抽屜

*   需要存儲多個元素時可采用鏈表或數組

*   數組元素都在一起，因此讀取速度快

*   鏈表是分開的，但是插入和刪除速度很快

*   鏈表數組查找比數組慢，比鏈表快；插入比數組快，與鏈表相當

*   同一數組元素的類型均相同

 尋找數組中的最小值的索引
def find_smallest_index(arr):
    smallest = arr[0]
    smallest_index = 0;
    # python中檢查數組長度的函數是len，而matlab中是length
    for i in range(1, len(arr)):
        if arr[i] < smallest:
            smallest = arr[i]
            smallest_index = i
    return smallest_index

# 對數組進行排序
def selection_insort(arr):
    # create new array
    new_arr = []
    for i in range(len(arr)):
        smallest_index = find_smallest_index(arr)
        # array.pop()只能根據索引值彈出元素，so pop()應傳入索引值
        new_arr.append(arr.pop(smallest_index))
    return new_arr

mess_arr = [3, 1, 9, 2, 5, 4]
print("This is uninsort array: " + str(mess_arr))
insorted_arr = selection_insort(mess_arr)
print("This is insorted array: " + str(insorted_arr))

遞歸

*   使用循環程序性能可能更高，使用遞歸程序可能更容易理解

*   遞歸條件——讓函數調用自己；基線條件——讓函數不再調用自己

*   所有函數調用都進入遞歸調用棧

# 一個計算數學階乘的遞歸調用
def func(x):
    if x == 1:
        return 1
    else:
        return x * func(x-1)

print(func(3))


#一個計算數組和的遞歸調用
def func(arr):
    if arr == []:
        return 0
    else:
        # 這里不能用arr[0] + func()因為基線條件是arr==[]當arr
        # 只有一個元素時python會將arr變為一個int數值，而不會是數組
        return arr.pop() + func(arr)

arr = [2, 3, 4]
print(func(arr))

快速排序，分而治之（D&C）

*   找出基線條件（很可能是一個空數組或者只包含一個元素的數組）

*   不斷將問題分解直至滿足基線條件

*   快速排序：

    *   選取基准值

    *   將數組分為兩個子數組：小於基准值的元素和大於基准值的元素

    *   對這兩個子數組進行快速排序

# 快速排序——by myself
def quickly_sort(arr):
    # 兩個基線條件
    if len(arr) < 2:
        return arr
    # 直接選取數組元素第一個當作基准值——遞歸條件
    reference_value = arr[0]
    larger_arr = []
    smaller_arr = []
    for i in range(1,len(arr)):
        if arr[i] > reference_value:
            larger_arr.append(arr[i])
            # arr.pop(i)
        else:
            smaller_arr.append(arr[i])
            # arr.pop(i)
    return quickly_sort(smaller_arr) + [reference_value] + quickly_sort(larger_arr)

mess_arr = [3, 1, 9, 2, 5, 4]
print("This is uninsort array: " + str(mess_arr))
insorted_arr = quickly_sort(mess_arr)
print("This is insorted array: " + str(insorted_arr))

# 快速排序——by others
def quickly_sort(arr):
    # 基線條件
    if len(arr) < 2:
        return arr
    else:
        # 選取基准值——遞歸條件
        pivot = arr[0]

        # 簡潔明了選出較大數組與較小數組
        larger = [i for i in arr[1:] if i > pivot]
        smaller = [i for i in arr[1:] if i <= pivot]
        # 遞歸調用
        return quickly_sort(smaller) + [pivot] + quickly_sort(larger)

mess_arr = [3, 1, 9, 2, 5, 4]
print("This is uninsort array: " + str(mess_arr))
insorted_arr = quickly_sort(mess_arr)
print("This is insorted array: " + str(insorted_arr))

 散列表——字典

*   散列函數——將輸入映射到數字；同一輸入映射一致，不同輸入映射到不同的數字

*   良好散列表包括：較低的填裝因子0.7以下，良好的散列函數SHA函數

*   散列表查找（O(1)）、刪除、插入都非常快

*   散列表適用於模擬映射關系、防止重復以及緩存數據

# 散列表——字典
# 創建字典的兩種方案
price_list = dict()
price_list = {}


# 添加數據
price_list["apple"] = 0.67
price_list["milk"] = 1.49
price_list["bread"] = 0.49

print(price_list)
print(price_list.keys())
print(price_list.values())
print(price_list.items())

# 判斷是否在散列表中
flag = price_list.get("apple")
print(flag)
# 不同大小寫詩不同與阿奴
flag = price_list.get("Apple")
print(flag)
flag = price_list.get("banana")
print(flag)

 廣度優先搜索——BFS

*   用於解決最短路徑

*   利用import collection import deque 創建一個雙端隊列

*   棧是LIFO，隊列是FIFO

*   廣度優先搜索時，對於檢查過的人不能再去檢查

# 廣度優先搜索示例
from collections import deque

# 創建一個關系圖（散列表）
graph = {}
# 單引號與雙引號基本無使用上的區別，但是三引號可實現跨行輸出
graph["you"] = ["alice", 'bob', "claire"]
graph["alice"] = ['peggy']
graph["bob"] = ["anuj", 'peggy']
graph['claire'] = ["thom", 'jonny']
graph["peggy"] = []
graph["anuj"] = []
graph["thom"] = []
graph["jonny"] = []


search_queue = deque()
search_queue += graph["you"]

# 判斷是否為經銷商
def person_is_seller(name):
    return (name[-1] == 'o')
        
def search(search_queue):
    searched = []
    while search_queue:
       
        person = search_queue.popleft()    #取出隊列左邊第一個元素
         # 檢查后不再檢查
        if person not in searched:
            if person_is_seller(person):
                print(person + " is a mago seller !")
                return True
            else:
                # 把TA的朋友加入搜索隊列
                search_queue += graph[person]
                searched.append(person)
    print("Can't find mago seller in your friends")
    return False
search(search_queue)

Dijkstra算法

*   找出目前最便宜的節點

*   更新該節點的鄰居的開銷

*   重復這個過程，直到對圖中所有節點都這么做了

*   計算最終路徑

*   Dijkstra算法只適用與有向無環圖

*   對於包含負權邊的圖，請使用貝爾曼-福德算法graph

# Dijkstra算法

# 尋找lowest_cost_node
def find_lowest_cost_node(costs):
    lowest_cost = float("inf")
    lowest_cost_node = None
    for node in costs:
        cost = costs[node]
        if cost < lowest_cost and node not in processed:
            lowest_cost = cost
            lowest_cost_node = node
    return lowest_cost_node


# Create a graph
graph = {}
graph['start'] = {}
graph['start']['a'] = 6
graph['start']['b'] = 2
graph['a'] = {}
graph['a']['fin'] = 1
graph['b'] = {}
graph['b']['fin'] = 5
graph['b']['a'] = 3
graph['fin'] = {}


# create a cost dict
infinity = float('inf')
costs = {}
costs['a'] = 6
costs['b'] = 2
costs['fin'] = infinity

# creata a parent dict
parents = {}
parents['a'] = "start"
parents['b'] = "start"
parents['fin']  = None


# record processed nodes
processed = []


node = find_lowest_cost_node(costs)
while node is not None:
    cost = costs[node]
    neighbors = graph[node]
    for n in neighbors.keys():
        new_cost = cost + neighbors[n]
        if costs[n] > new_cost:
            costs[n] = new_cost
            parents[n] = node
    processed.append(node)
    node = find_lowest_cost_node(costs)

route = ['fin']
node = parents['fin']
route.append(node)
node = parents[node]
route.append(node)
node = parents[node]
route.append(node)


print(route)

貪婪算法

*   衡量標准：速度有多快；得到的近似解與最優解的接近程度

*   易於實現，運行速度快

*   識別NP完全問題

    *   隨着元素的增加操作速度極速增加

    *   涉及“所有組合”的問題通常是NP完全問題

    *   問題可轉換為集合覆蓋問題和旅行商問題