演算法(Python),演算法python
演算法就是為瞭解決某一個問題而採取的具體有效操作步驟
演算法的複雜度,表示代碼的運行效率,用一個大寫的O加括弧來表示,比如O(1),O(n)
認為演算法的複雜度是漸進的,即對於一個大小為n的輸入,如果他的運算時間為n3+5n+9,那麼他的漸進時間複雜度是n3
遞迴
遞迴就是在函數中調用本身,大多數情況下,這會給電腦增加壓力,但是有時又很有用,比如下面的例子:
漢諾塔遊戲
把A柱的盤子,移動到C柱上,最少需要移動幾次,大盤子只能在小盤子下面
遞迴實現:
def hanoi(x, a, b, c): # 所有的盤子從 a 移到 c if x > 0: hanoi(x-1, a, c, b) # step1:除了下面最大的,剩餘的盤子 從 a 移到 b print('%s->%s' % (a, c)) # step2:最大的盤子從 a 移到 c hanoi(x-1, b, a, c) # step3: 把剩餘的盤子 從 b 移到 chanoi(10, 'A', 'B', 'C')#計算次數def h(x): num = 1 for i in range(x-1): num = 2*num +1 print(num)h(10)用遞迴列印斐波那契數列
def fei(n): if n == 0: return 0 elif n == 1: return 1 else: return fei(n-1)+fei(n-2)
你會發現,即使n只有幾十的時候,你的電腦記憶體使用量量已經飆升了
其實,如果結合產生器,你會發現不管n有多大,都不會出現卡頓,但這是產生器的特性,本篇部落格不重點介紹
# 結合產生器def fei(n): pre,cur = 0,1 while n >=0: yield pre n -= 1 pre,cur = cur,pre+curfor i in fei(400000): print(i)
關於遞迴次數,Python中有個限制,可以通過sys模組來修改
import syssys.setrecursionlimit(1000000)
尋找1.
順序尋找
這個沒的說,就是for迴圈唄,時間複雜度O(n)
def linear_search(data_set, value): for i in range(len(data_set)): if data_set[i] == value: return i return
2.
二分尋找
時間複雜度O(logn)
就是一半一半的尋找,看目標值在左邊一半還是右邊一半,然後替換左端點或者右端點,繼續判斷
非遞迴版本:
def binary_serach(li,val): low = 0 high = len(li)-1 while low <= high: mid = (low+high)//2 if li[mid] == val: return mid elif li[mid] > val: high = mid-1 else: low = mid+1 else: return None
遞迴版本的二分尋找
def bin_search_rec(data_set, value, low, high): if low < high: mid = (low + high) // 2 if data_set[mid] == value: return mid elif data_set[mid] > value: return bin_search_rec(data_set, value, low, mid - 1) else: return bin_search_rec(data_set, value, mid + 1, high) else: return None
排序
速度慢的三個:
1.
冒泡排序
原理就是,列表相鄰的兩個數,如果前邊的比後邊的小,那麼交換順序,經過一次排序後,最大的數就到了列表最前面
代碼:
def bubble_sort(li): for j in range(len(li)-1): for i in range(1, len(li)): if li[i] > li[i-1]: li[i], li[i-1] = li[i-1], li[i] return li
冒泡排序的最差情況,即每次都互動順序的情況,時間複雜度是O(n2)
存在一個最好情況就是列表本來就是排好序的,所以可以加一個最佳化,加一個標誌位,如果沒有出現交換順序的情況,那就直接return
# 最佳化版本的冒泡def bubble_sort_opt(li): for j in range(len(li)-1): flag = False for i in range(1, len(li)): if li[i] > li[i-1]: li[i], li[i-1] = li[i-1], li[i] flag = True if not flag: return li return li
2.
插入排序
原理:把列表分為有序區和無序區兩個部分。最初有序區只有一個元素。然後每次從無序區選擇一個元素,插入到有序區的位置,直到無序區變空。
def insert_sort(li): for i in range(1,len(li)): tmp = li[i] j = i - 1 while j >= 0 and tmp < li[j]: # 找到一個合適的位置插進去 li[j+1] = li[j] j -= 1 li[j+1] = tmp return li
時間複雜度是O(n2)
3.
選擇排序
原理:遍曆列表一遍,拿到最小的值放到列表第一個位置,再找到剩餘列表中最小的值,放到第二個位置。。。。
def select_sort(li): for i in range(len(li)-1): min_loc = i # 假設當前最小的值的索引就是i for j in range(i+1,len(li)): if li[j] < li[min_loc]: min_loc = j if min_loc != i: # min_loc 值如果發生過交換,表示最小的值的下標不是i,而是min_loc li[i],li[min_loc] = li[min_loc],li[i] return li
時間複雜度是O(n2)
速度快的幾種排序:
4.
快速排序(快排)
原理:讓指定的元素歸位,所謂歸位,就是放到他應該放的位置(左變的元素比他小,右邊的元素比他大),然後對每個元素歸位,就完成了排序
可以參考這個動圖來理解下面的代碼
代碼:
# 歸位函數def partition(data, left, right): # 左右分別指向兩端的元素 tmp = data[left] # 把左邊第一個元素賦值給tmp,此時left指向空 while left < right: # 左右兩個指標不重合,就繼續 while left < right and data[right] >= tmp: # right指向的元素大於tmp,則不交換 right -= 1 # right 向左移動一位 data[left] = data[right] # 如果right指向的元素小於tmp,就放到左邊現在為空白的位置 while left < right and data[left] <= tmp: # 如果left指向的元素小於tmp,則不交換 left += 1 # left向右移動一位 data[right] = data[left] # 如果left指向的元素大於tmp,就交換到右邊 data[left] = tmp # 最後把最開始拿出來的那個值,放到左右重合的那個位置 return left # 最後返回這個位置# 寫好歸位函數後,就可以遞迴調用這個函數,實現排序def quick_sort(data, left, right): if left < right: mid = partition(data, left, right) # 找到指定元素的位置 quick_sort(data, left, mid - 1) # 對左邊元素排序 quick_sort(data, mid + 1, right) # 對右邊元素排序 return data
正常的情況,快排的複雜度是O(nlogn)
快排存在一個最壞情況,就是每次歸位,都不能把列表分成兩部分,此時複雜度就是O(n2)了,如果要避免設計成這種最壞情況,可以在取第一個數的時候不要取第一個了,而是取一個列表中的隨機數
5.
歸併排序
原理:列表分成兩段有序,然後分解成每個元素後,再合并成一個有序列表,這種操作就叫做一次歸併
應用到排序就是,把列表分成一個元素一個元素的,一個元素當然是有序的,將有序列表一個一個合并,最終合并成一個有序的列表
圖示:
代碼:
def merge(li, left, mid, right): # 一次歸併過程,把從mid分開的兩個有序列表合并成一個有序列表 i = left j = mid + 1 ltmp = [] # 兩個列表的元素依次比較,按從大到小的順序放到一個臨時的空列表中 while i <= mid and j <= right: if li[i] < li[j]: ltmp.append(li[i]) i += 1 else: ltmp.append(li[j]) j += 1 # 如果兩個列表並不是平均分的,就會存在有元素沒有加入到臨時列表的情況,所以再判斷一下 while i<= mid: ltmp.append(li[i]) i += 1 while j <= right: ltmp.append(li[j]) j += 1 li[left:right+1] = ltmp return lidef _merge_sort(li, left, right): # 細分到一個列表中只有一個元素的情況,對每一次都調用merge函數變成有序的列表 if left < right: mid = (left+right)//2 _merge_sort(li, left, mid) _merge_sort(li, mid+1, right) merge(li, left, mid, right) return lidef merge_sort(li): return(_merge_sort(li, 0, len(li)-1))
照例,時間複雜度是O(nlogn)
特殊的,歸併排序還有一個O(n)的空間複雜度
6.
堆排序
把這個放到最後,是因為這個是最麻煩的,把最麻煩的放到最後,是一種對工作負責的表現
如果要說堆排序,首先得先把‘樹’搞明白
樹
樹是一種資料結構;
樹是由n個節點群組成的集合; -->如果n為0,那這是一顆空樹,如果n>0,那麼那存在1個節點作為樹的根節點,其他節點可以分為m個集合,每個集合本身又是一棵樹。
一些可能會用到的概念:
根節點:樹的第一個節點,沒有父節點的節點
葉子節點:不帶分叉的節點
樹的深度(高度):就是分了多少層
孩子節點、父節點:節點與節點之間的關係
圖示:
二叉樹
然後在樹的基礎上,有一個二叉樹,二叉樹就是每個節點最多有兩個子節點的樹結構,比如這個:
滿二叉樹:除了葉子節點,所有節點都有兩個孩子,並且所有葉子節點深度都一樣
完全二叉樹:是有滿二叉樹引申而來,假設二叉樹深度為k,那麼除了第k層,之前的每一層的節點數都達到最大,即沒有空的位置,而且第k層的子節點也都集中在左子樹上(順序)
二叉樹的儲存方式
有鏈式儲存和順序儲存的方式(列表),本篇只討論順序儲存的方式
思考:
父節點和左孩子節點的編號下標有什麼關係? 0-1 1-3 2-5 3-7 4-9 i ----> 2i+1
父節點和右孩子節點的編號下標有什麼關係? 0-2 1-4 2-6 3-8 4-10 i -----> 2i+2
再來瞭解下堆,堆說起來又麻煩了,我將在另一篇部落格中單獨寫堆,棧等這些資料結構,本篇先討論與排序有關的東西
堆
堆是一類特殊的樹,要求父節點大於或小於所有的子節點
大根堆:一棵完全二叉樹,滿足任一節點都比其孩子節點大 ,升序用大根堆
小根堆:一棵完全二叉樹,滿足任一節點都比其孩子節點小
堆的調整:當根節點的左右子樹都是堆時,可以通過一次向下的調整來將其變換成一個堆。
所謂一次向下調整,就是說把堆頂的值,向下找一個合適的位置,是一次一次的找,跟他交換位置的值,也要找到一個合適的位置
“瀏覽器寫的沒儲存,丟失了,所以這塊不想再寫了。。。”
堆排序的過程
1.構造堆
2.得到堆頂元素,就是最大的元素
3.去掉堆頂,將堆的最後一個元素放到堆頂,此時可以通過一次調整重新使堆有序
4.堆頂元素為第二大元素
5.重複步驟3,直到堆為空白
其中構造堆的過程:
挨個出數的過程:
代碼:
def sift(li, left, right): # left和right 表示了元素的範圍,是根節點到右節點的範圍,然後比較根和兩個孩子的大小,把大的放到堆頂 # 和兩個孩子的大小沒關係,因為我們只需要拿堆頂的元素就行了 # 構造堆 i = left # 當作根節點 j = 2 * i + 1 # 上面提到過的父節點與左子樹根節點的編號下標的關係 tmp = li[left] while j <= right: if j+1 <= right and li[j] < li[j+1]: # 找到兩個孩子中比較大的那個 j = j + 1 if tmp < li[j]: # 如果孩子中比較大的那個比根節點大,就交換 li[i] = li[j] i = j # 把交換了的那個節點當作根節點,迴圈上面的操作 j = 2 * i + 1 else: break li[i] = tmp # 如果上面發生交換,現在的i就是最後一層符合條件(不用換)的根節點,def heap_sort(li): n = len(li) for i in range(n//2-1, -1, -1): # 建立堆 n//2-1 是為了拿到最後一個子樹的根節點的編號,然後往前走,最後走到根節點0//2 -1 = -1 sift(li, i, n-1) # 固定的把最後一個值的位置當作right,因為right只是為了判斷遞迴不要超出當前樹,所以最後一個值可以滿足 # 如果每遍曆一個樹,就找到它的右孩子,太麻煩了 for i in range(n-1, -1, -1): # 挨個出數 li[0], li[i] = li[i],li[0] # 把堆頂與最後一個數交換,為了節省空間的,否則還可以建立一個列表,把堆頂(最大數)放到新列表中 sift(li, 0, i-1) # 此時的列表,應該排除最後一個已經排好序的,放置最大值的位置,所以i-1
時間複雜度也是O(nlogn)
來擴充一下,如果要取一個列表的top10,就是取列表的前十大的數,怎麼做?
可以用堆來實現,取堆的前十個數,構造成一個小根堆,然後依次遍曆列表後面的數,如果比堆頂小,則忽略,如果比堆頂大,則將堆頂替換成改元素,然後進行一次向下調整,最終這個小根堆就是top10
其實Python內建一個heapq模組,就是幫我們對堆進行操作的
heapq模組
隊列中的每個元素都有優先順序,優先順序最高的元素優先得到服務(操作),這就是優先隊列,而優先隊列通常用堆來實現
如果用heapq模組來實現堆排序,就簡單多了:
import heapqdef heapq_sort(li): h = [] for value in li: heapq.heappush(h,value) return [heapq.heappop(h) for i in range(len(h))]
而想取top10 ,直接一個方法就行了
heapq.nlargest(10,li)
這三種速度快的排序方式就說完了,其中,快排是速度最快的,即使這樣,也不如Python內建的sort快
再來介紹兩種排序,希爾排序和計數排序
7.希爾排序
希爾排序是一種分組插入排序的演算法
思路:
首先取一個整數d1=n/2,將元素分為d1個組,每組相鄰量元素之間距離為d1,在各組內進行直接插入排序;
取第二個整數d2=d1/2,重複上述分組排序過程,直到di=1,即所有元素在同一組內進行直接插入排序。
希爾排序每趟並不使某些元素有序,而是使整體資料越來越接近有序;最後一趟排序使得所有資料有序。
圖示:
代碼:
def shell_sort(li):
gap = int(len(li)//2) # 初始把列表分成 gap個組,但是每組最多就兩個元素,第一組可能有三個元素
while gap >0:
for i in range(gap,len(li)):
tmp = li[i]
j = i - gap
while j>0 and tmp<li[j]: # 對每一組的每一個數,都和他前面的那個數比較,小的在前面
li[j+gap] = li[j]
j -= gap
li[j+gap] = tmp
gap = int(gap//2) # Python3中地板除也是float類型
return li
通過diamante也能看出來,其實希爾排序和插入排序是非常相像的,插入排序就可以看做是固定間隔為1的希爾排序,希爾排序就是把插入排序分了個組,同一個組內,相鄰兩個數之間不是相差1,而是相差gap
時間複雜度:O((1+t)n),其中t是個大於0小於1的數,取決於gap的取法,當gap=len(li)//2的時候,t大約等於0.3
8.計數排序
需求:有一個列表,列表中的數都在0到100之間(整數),列表長度大約是100萬,設計演算法在O(n)時間複雜度內將列表進行排序
分析:列表長度很大,但是資料量很少,會有大量的重複資料。可以考慮對這100個數進行排序
代碼:
def count_sort(li): count = [0 for i in range(101)] # 根據原題,0-100的整數 for i in li: count[i] += 1 i = 0 for num,m in enumerate(count): # enumerate函數將一個可遍曆的資料對象(如列表、元組或字串)組合為一個索引序列,同時列出資料和資料下標,一般用在 for 迴圈當中。 for j in range(m): li[i] = num i += 1