關注頭條號，私信回復資料會有意外驚喜呦………………最後一張照片有資料呦。

冒泡排序：

def bubble_sort(alist):

n = len(alist)

count = 0

for i in range(n-1):

for j in range(n-1-i): # 為排好序的元素個數

if alist[j] > alist[j + 1]:

alist[j], alist[j+1] = alist[j+1], alist[j]

count += 1

if count == 0:

break

print(count)

if __name__ == ‘__main__’:

alist = [3,4,6,8,9]

bubble_sort(alist)

print(alist)

選擇排序：

”’

選擇排序：時間複雜度 O(n^2)

列表： list = [2,4,7,7,5,1]

查找指定元素的下標

index = list.index(4)

刪除指定元素

list.remove(4)

刪除指定下標

del list[0]

”’

def selection_sort(alist):

n = len(alist)

# n-1 是因為最後一個數不用排序

for i in range(n-1):

min_index = i

for j in range(i+1, n):

if alist[j] < alist[min_index]:

min_index = j

if min_index != i:

alist[i], alist[min_index] = alist[min_index], alist[i]

if __name__ == ‘__main__’:

list = [2, 4, 7, 7, 5, 1, 8, 3]

selection_sort(list)

print(list)

快速排序：

”’

快速排序

最優時間複雜度：O(nlogn)

最壞時間複雜度：O(n2)

”’

def quick_sort(arr):

if len(arr) <= 1:

return arr

mark = arr[0]

less = [i for i in arr[1:] if i <= mark]

greater = [i for i in arr[1:] if i > mark]

res = quick_sort(less) + [mark] + quick_sort(greater)

return res

# 拆分式

def quick_sort2(arr):

if len(arr) <= 1:

return arr

mark = arr[0]

less = []

greater = []

for i in arr:

if i <= mark:

less.append(i)

if i > mark:

greater.append(i)

res = quick_sort(less) + quick_sort(greater)

return res

if __name__ == ‘__main__’:

alist = [5, 6, 2, 7, 3]

result = quick_sort2(alist)

print(result)

插入排序：

”’

插入排序：

最優時間複雜度：O(n)

最壞時間複雜度：O(n2)

”’

def insert_sort(alist):

n = len(alist)

for i in range(1, n):

# 用該元素和前面的元素比較， 如果比前一個小，交換位置

for j in range(i, 0, -1):

if alist[j] < alist[j-1]:

alist[j], alist[j-1] = alist[j-1], alist[j]

if __name__ == ‘__main__’:

list = [2, 4, 7, 7, 5, 1, 8, 3]

insert_sort(list)

print(list)

歸並排序：

#coding:utf-8

def merge_sort(alist):

# 列表拆分

n = len(alist)

mid = n // 2

if n == 1:

return alist

sorted_list = []

left_list = merge_sort(alist[:mid])

right_list = merge_sort(alist[mid:])

left, right = 0, 0

left_n = len(left_list)

right_n = len(right_list)

# 當索引分別小於左右兩個列表長度的時候說明遊標沒有遍歷完任何一個列表，此時不斷重復對比

while left < left_n and right < right_n:

# 對比兩個列表中的數值，小的放到返回列表中

if left_list[left] < right_list[right]:

sorted_list.append(left_list[left])

left += 1

else:

sorted_list.append(right_list[right])

right += 1

# 循環結束之後，有一個列表尚未遍歷完畢，此時採用列表相加的方式將剩餘數據添加到返回列表的尾部，剩餘數據是有序的，將大於返回列表之前的所有數據

sorted_list += left_list[left:]

sorted_list += right_list[right:]

return sorted_list

if __name__ == ‘__main__’:

alist = [12,34,56,78,90,98,76,54,32,21]

result = merge_sort(alist)

print(alist)

print(result)

二分查找：

”’

二分查找 僅當數列有序時才管用， 使用的最多步驟為log2n(2為底數)

時間複雜度 O(logn)

”’

def binary_search(list, item):

low = 0

high = len(list) – 1

while low <= high:

mid = (low + high)//2

guess = list[mid]

if guess == item:

return mid

if guess > item:

high = mid – 1

else:

low = mid + 1

return None

if __name__ == ‘__main__’:

mylist = [1, 3, 5, 7, 9, 11]

index = binary_search(mylist, 13)

print(index)

二叉樹：

性質1:在二叉樹的第i層上至多有2^(i-1)個結點（i>0）

性質2:深度為k的二叉樹至多有2^k – 1個結點（k>0）

性質3:對於任意一棵二叉樹，如果其葉結點數為N0，而度數為2的結點總數為N2，則N0=N2+1;

性質4:具有n個結點的完全二叉樹的深度必為 log2(n+1)

性質5:對完全二叉樹，若從上至下、從左至右編號，則編號為i 的結點，其左孩子編號必為2i，其右孩子編號必為2i＋1；其雙親的編號必為i/2（i＝1 時為根,除外）

完全二叉樹： 最多只有2個子節點

滿二叉樹： 特殊的完全二叉樹，除最外層，每個節點都有2個節點

二叉樹的遍歷

廣度遍歷 — 層級遍歷

深度遍歷：都是根據根節點決定

先序遍歷：

中序遍歷：

後序遍歷：

# 創建二叉樹

class Binary_tree(object):

def __init__(self):

self.root = None

def add(self, item):

new_Node = Node(item)

# 判斷是否為空樹

if not self.root:

self.root = new_Node

else:

# 創建節點保持隊列

queue = []

queue.append(self.root)

# 遍歷所有節點

while len(queue) > 0:

# 獲取一個節點，判斷其左右節點是否存在，如有缺失補充

node = queue.pop(0)

if node.lchild:

queue.append(node.lchild)

else:

node.lchild = new_Node

return

if node.rchild:

queue.append(node.rchild)

else:

node.rchild = new_Node

return

二叉樹的遍歷

# 廣度優先遍歷

def breadth_travel(self):

if not self.root:

return

else:

queue = []

queue.append(self.root)

while len(queue) > 0:

node = queue.pop(0)

print(node.item, end=’ ‘)

if node.lchild:

queue.append(node.lchild)

if node.rchild:

queue.append(node.rchild)

# 深度優先遍歷

# 先序遍歷

def pre_travel(self, root):

if root:

print(root.item, end=” “)

self.pre_travel(root.lchild)

self.pre_travel(root.rchild)

# 中序遍歷

def in_travel(self, root):

if root:

self.in_travel(root.lchild)

print(root.item, end=” “)

self.in_travel(root.rchild)

# 後序遍歷

def after_travel(self, root):

if root:

self.after_travel(root.lchild)

self.after_travel(root.rchild)

print(root.item, end=” “)

二叉樹測試：

if __name__ == ‘__main__’:

bTree = Binary_tree()

bTree.add(0)

bTree.add(1)

bTree.add(2)

bTree.add(3)

bTree.add(4)

bTree.add(5)

bTree.add(6)

bTree.add(7)

bTree.add(8)

bTree.add(9)

bTree.breadth_travel()

print()

bTree.pre_travel(bTree.root)

print()

bTree.in_travel(bTree.root)

print()

bTree.after_travel(bTree.root)

很多人在問，學習Python讀什麼書，這其實是一個非常通用的問題，學習分為三種方式：看書、上課，而讀書學習是最實惠也是最高效的一種，小編整理了一些Python高分書籍給大家，從0基礎到高級適合不同學習階段，希望大家學習愉快。獲取方式：點擊小編頭像，關注後私信回復「資料」即可下載。