Python 歸併排序
歸併排序（英語：Merge sort，或mergesort），是創建在歸併操作上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。
分治法:
分割：遞歸地把當前序列平均分割成兩半。
集成：在保持元素順序的同時將上一步得到的子序列集成到一起（歸併）。
實例
def merge(arr, l, m, r):
n1 = m - l + 1
n2 = r- m
# 創建臨時數組
L = [0] * (n1)
R = [0] * (n2)
# 拷貝數據到臨時數組 arrays L[] 和 R[]
for i in range(0 , n1):
L[i] = arr[l + i]
for j in range(0 , n2):
R[j] = arr[m + 1 + j]
# 歸併臨時數組到 arr[l..r]
i = 0 # 初始化第一個子數組的索引
j = 0 # 初始化第二個子數組的索引
k = l # 初始歸併子數組的索引
while i < n1 and j < n2 :
if L[i] <= R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
# 拷貝 L[] 的保留元素
while i < n1:
arr[k] = L[i]
i += 1
k += 1
# 拷貝 R[] 的保留元素
while j < n2:
arr[k] = R[j]
j += 1
k += 1def mergeSort(arr,l,r):
if l < r:
m = int((l+(r-1))/2)
mergeSort(arr, l, m)
mergeSort(arr, m+1, r)
merge(arr, l, m, r) arr = [12, 11, 13, 5, 6, 7]
n = len(arr)
print ("給定的數組")
for i in range(n):
print("%d" %arr[i]),
mergeSort(arr,0,n-1)
print ("\n\n排序後的數組")
for i in range(n):
print ("%d" %arr[i]),
執行以上代碼輸出結果爲：
給定的數組121113567
排序後的數組567111213
Python 堆排序
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。堆排序可以說是一種利用堆的概念來排序的選擇排序。
實例
def heapify(arr, n, i):
largest = i
l = 2 i + 1 # left = 2i + 1
r = 2 i + 2 # right = 2i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n andarr[largest] < arr[r]:
largest = r
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i] # 交換
heapify(arr, n, largest) def heapSort(arr):
n = len(arr)
# Build a maxheap.
for i in range(n, -1, -1):
heapify(arr, n, i)
# 一個個交換元素
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # 交換
heapify(arr, i, 0) arr = [ 12, 11, 13, 5, 6, 7]
heapSort(arr)
n = len(arr)
print ("排序後")
for i in range(n):
print ("%d" %arr[i]),
執行以上代碼輸出結果爲：
排序後
5
6
7
11
12
13
Python 計數排序
計數排序的核心在於將輸入的數據值轉化爲鍵存儲在額外開闢的數組空間中。作爲一種線性時間複雜度的排序，計數排序要求輸入的數據必須是有確定範圍的整數。
實例
def countSort(arr):
output = [0 for i in range(256)]
count = [0 for i inrange(256)]
ans = ["" for _ in arr]
for i in arr:
count[ord(i)] += 1
for iin range(256):
count[i] += count[i-1]
for i in range(len(arr)):
output[count[ord(arr[i])]-1] = arr[i]
count[ord(arr[i])] -= 1
for i inrange(len(arr)):
ans[i] = output[i]
return ans arr = "wwwrunoobcom"
ans = countSort(arr)
print ( "字符數組排序 %s" %("".join(ans)) )
執行以上代碼輸出結果爲：
符數組排序 bcmnoooruwww
Python 希爾排序
希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。
希爾排序的基本思想是：先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄"基本有序"時，再對全體記錄進行依次直接插入排序。
實例
def shellSort(arr):
n = len(arr)
gap = int(n/2)
while gap > 0:
for i inrange(gap,n):
temp = arr[i]
j = i
while j >= gap and arr[j-gap] >temp:
arr[j] = arr[j-gap]
j -= gap
arr[j] = temp
gap = int(gap/2)arr = [ 12, 34, 54, 2, 3]
n = len(arr)
print ("排序前:")
for i inrange(n):
print(arr[i]),
shellSort(arr)
print ("\n排序後:")
for i in range(n):
print(arr[i]),
執行以上代碼輸出結果爲：
排序前:
12
34
54
2
3
排序後:
2
3
12
34
54
Python 拓撲排序
對一個有向無環圖(Directed Acyclic Graph簡稱DAG)G進行拓撲排序，是將G中所有頂點排成一個線性序列，使得圖中任意一對頂點u和v，若邊(u,v)∈E(G)，則u在線性序列中出現在v之前。
通常，這樣的線性序列稱爲滿足拓撲次序(Topological Order)的序列，簡稱拓撲序列。簡單的說，由某個集合上的一個偏序得到該集合上的一個全序，這個操作稱之爲拓撲排序。
在圖論中，由一個有向無環圖的頂點組成的序列，當且僅當滿足下列條件時，稱爲該圖的一個拓撲排序（英語：Topological sorting）：
每個頂點出現且只出現一次；
若A在序列中排在B的前面，則在圖中不存在從B到A的路徑。
實例
from collections import defaultdict
class Graph:
def init(self,vertices):
self.graph = defaultdict(list)
self.V = vertices
def addEdge(self,u,v):
self.graph[u].append(v)
def topologicalSortUtil(self,v,visited,stack):
visited[v] = True
for i in self.graph[v]:
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
stack.×××ert(0,v)
deftopologicalSort(self):
visited = [False]*self.V
stack =[]
for i inrange(self.V):
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
print (stack) g= Graph(6)
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
print ("拓撲排序結果：")
g.topologicalSort()
執行以上代碼輸出結果爲：
拓撲排序結果：
[5, 4, 2, 3, 1, 0]
最後免費贈送一個實例：
Python 計算笛卡爾積
計算多個集合的笛卡爾積，有規律可循，算法和代碼也不難，但是很多語言都沒有提供直接計算笛卡爾積的方法，需要自己寫大段大段的代碼計算笛卡爾積，python 提供了一種最簡單的計算笛卡稱積的方法(只需要一行代碼)，詳見下面的代碼：
#!/usr/bin/python3
-- coding: utf-8 --
@file : Cartesian.py
@author : shlian
@date : 2018/5/29
@version: 1.0
@desc : 用python實現求笛卡爾積
import itertools
class cartesian(object):
def init(self):
self._data_list=[]
def add_data(self,data=[]): #添加生成笛卡爾積的數據列表
self._data_list.append(data)
def build(self): #計算笛卡爾積
for item in itertools.product(*self._data_list):
print(item)if name=="main":
car=cartesian()
car.add_data([1,2,3,4])
car.add_data([5,6,7,8])
car.add_data([9,10,11,12])
car.build()
計算的結果如下：
(1, 5, 9)
(1, 5, 10)
(1, 5, 11)
(1, 5, 12)
(1, 6, 9)
(1, 6, 10)
(1, 6, 11)
(1, 6, 12)
(1, 7, 9)
(1, 7, 10)
(1, 7, 11)
(1, 7, 12)
(1, 8, 9)
(1, 8, 10)
(1, 8, 11)
(1, 8, 12)
(2, 5, 9)
(2, 5, 10)
(2, 5, 11)
(2, 5, 12)
(2, 6, 9)
(2, 6, 10)
(2, 6, 11)
(2, 6, 12)
(2, 7, 9)
(2, 7, 10)
(2, 7, 11)
(2, 7, 12)
(2, 8, 9)
(2, 8, 10)
(2, 8, 11)
(2, 8, 12)
(3, 5, 9)
(3, 5, 10)
(3, 5, 11)
(3, 5, 12)
(3, 6, 9)
(3, 6, 10)
(3, 6, 11)
(3, 6, 12)
(3, 7, 9)
(3, 7, 10)
(3, 7, 11)
(3, 7, 12)
(3, 8, 9)
(3, 8, 10)
(3, 8, 11)
(3, 8, 12)
(4, 5, 9)
(4, 5, 10)
(4, 5, 11)
(4, 5, 12)
(4, 6, 9)
(4, 6, 10)
(4, 6, 11)
(4, 6, 12)
(4, 7, 9)
(4, 7, 10)
(4, 7, 11)
(4, 7, 12)
(4, 8, 9)
(4, 8, 10)
(4, 8, 11)
(4, 8, 12)
好了，本文就給大夥分享到這裏，文末分享一波福利
獲取方式：加python羣 839383765 即可獲取！