文章目錄

• 二分查找
• 線性查找
• 插入排序
• 快速排序
• 選擇排序
• 冒泡排序
• 歸并排序
• 堆排序
• • 推薦代碼一
  • 推薦代碼二
• 希爾排序
• 拓撲排序

說明：本篇博文的知識點大部分來自 Python3 實例

二分查找

二分搜索是一種在有序數組中查找某一特定元素的搜索算法。
這種搜索算法每一次比較都使搜索范圍縮小一半。
二分查找有一個特定條件，對于有序且從小到大排列的容器才能使用

這是從菜鳥教程里面截取的一張圖，很好的解釋了二分查找。

輸入數值為4，一半是第五位：7，小于7，在前半部分。再一半取得第二位：3，大于3，在3之后的半部分里面，這樣一直二分，直到查找到最終結果。

def binarySearch(lst2, fst, len1, num1):if len1 >= fst:mid = int(fst + (len1 - fst) / 2)if lst2[mid] == num1:return midelif lst2[mid] > num1:return binarySearch(lst2, fst, mid - 1, num1)else:return binarySearch(lst2, mid + 1, len1, num1)else:return -1lst1 = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]rst = binarySearch(lst1, 0, len(lst1) - 1, 8)if rst != -1:print("元素在列表中的索引為 ", rst) else:print("元素不在數組中")

運行結果：

線性查找

線性查找指按一定的順序檢查數組中每一個元素，直到找到所要尋找的特定值為止。

這是從菜鳥教程里面截取的一張圖，很好的解釋了二分查找。

我個人覺得這個就是常用的變量，沒什么特別的。
上代碼：

lst2 = [2, 3, 4, 5, 6, 7, 8, 9]def search(lst3, len3, num3):for idx in range(0, len3):if lst3[idx] == num3:return idxreturn -1num2 = 6 rst2 = search(lst2, len(lst2), num2)if rst2 != -1:print("元素在數組中的索引為", rst2) else:print("元素不在數組中")

運行結果：

插入排序

插入排序是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。
Python 插入排序
插入排序大家進入這個網址取看吧。主要他的那個動圖很有形象。弄不過來。

這張圖，可以去網址里面看看它的實現邏輯。Python 插入排序

上代碼：

def insertionSort(lst5):for idx1 in range(1, len(lst5)):key = lst5[idx1]idx2 = idx1 - 1while idx2 >= 0 and key < lst5[idx2]:lst5[idx2 + 1] = lst5[idx2]idx2 -= 1lst5[idx2 + 1] = keylst4 = [12, 11, 13, 5, 6, 234, 1] insertionSort(lst4) print("排序后的數組:") for i in range(len(lst4)):print("%d" % lst4[i])

運行結果：

快速排序

快速排序使用分治法策略來把一個序列分為較小和較大的2個子序列，然后遞歸地排序兩個子序列。

def partition(lst03, low, high):idx1 = (low - 1)pivot = lst03[high]for j in range(low, high):if lst03[j] <= pivot:idx1 = idx1 + 1lst03[idx1], lst03[j] = lst03[j], lst03[idx1]lst03[idx1 + 1], lst03[high] = lst03[high], lst03[idx1 + 1]return idx1 + 1def quickSort(lst02, low, high):if low < high:pi = partition(lst02, low, high)quickSort(lst02, low, pi - 1)quickSort(lst02, pi + 1, high)lst01 = [10, 7, 8, 9, 1, 5] quickSort(lst01, 0, len(lst01) - 1) print("排序后的數組:") for i in range(len(lst01)):print("lst01[{idx}] = {val}".format(idx=i, val=lst01[i]))

運行結果：

選擇排序

選擇排序是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

這也是從菜鳥教程里面截取的一張圖：

這張圖，可以去網址里面看看它的實現邏輯。Python 選擇排序

lst03 = [64, 25, 12, 22, 11, 35, 2, 9, 123]for i in range(len(lst03)):minIdx = ifor j in range(i + 1, len(lst03)):if lst03[minIdx] > lst03[j]:minIdx = jlst03[i], lst03[minIdx] = lst03[minIdx], lst03[i]print("排序后的數組：") for i in range(len(lst03)):print("lst03[{idx}] = {val}".format(idx=i, val=lst03[i]))

運行結果：

冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。
走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。

這張圖，可以去網址里面看看它的實現邏輯。Python 冒泡排序

代碼：

lst04 = [23, 64, 25, 11, 76, 12, 22]def bubbleSort(lst05):n = len(lst05)for idx1 in range(n):for idx2 in range(0, n - idx1 - 1):if lst05[idx2] > lst05[idx2 + 1]:lst05[idx2], lst05[idx2 + 1] = lst05[idx2 + 1], lst05[idx2]bubbleSort(lst04)print("排序后的數組:") for i in range(len(lst04)):print("lst04[{idx}] = {val}".format(idx=i, val=lst04[i]))

運行結果：

歸并排序

歸并排序（英語：Merge sort，或mergesort），是創建在歸并操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。

分治法:

分割：遞歸地把當前序列平均分割成兩半。
集成：在保持元素順序的同時將上一步得到的子序列集成到一起（歸并）。

這是歸并排序的動圖示例：

我這里的圖不會動，想看動圖示例到這里看：Python 歸并排序
大家可以查看這個網址，有圖例展示歸并排序的過程。
Python 歸并排序

def merge(arr, l, m, r):n1 = m - l + 1n2 = r - mL = [0] * (n1)R = [0] * (n2)for i in range(0, n1):L[i] = arr[l + i]for j in range(0, n2):R[j] = arr[m + 1 + j]i = 0j = 0k = lwhile i < n1 and j < n2:if L[i] <= R[j]:arr[k] = L[i]i += 1else:arr[k] = R[j]j += 1k += 1while i < n1:arr[k] = L[i]i += 1k += 1while j < n2:arr[k] = R[j]j += 1k += 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, 9, 234, 23, 123, 45] 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])

運行結果：

堆排序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，并同時滿足堆積的性質：即子結點的鍵值或索引總是小于（或者大于）它的父節點。堆排序可以說是一種利用堆的概念來排序的選擇排序。
示意圖：

可以看這里，查看動態堆排序示意圖：
Python 堆排序

推薦代碼一

def OneHeapSort(list1, l, r):if r - l <= 0:returnif r - l == 1 and list1[l] > list1[r]:list1[l], list1[r] = list1[r], list1[l]else:middle = l + (r - l - 1) // 2OneHeapSort(list1, l, middle)OneHeapSort(list1, middle + 1, r - 1)if list1[middle] > list1[r]:list1[middle], list1[r] = list1[r], list1[middle]if list1[r - 1] > list1[r]:list1[r - 1], list1[r] = list1[r], list1[r - 1]# 依次將最大值放到數組的后面 def heapSort(list):for i in range(len(list) - 1, 0, -1):OneHeapSort(list, 0, i)list1 = [12, 11, 13, 5, 6, 7, 9, 234, 23, 123, 45] heapSort(list1) print(list1)

運行結果：

推薦代碼二

def heapify(arr):n = len(arr)for i in reversed(range(n // 2)):shiftDown(arr, n, i)def shiftDown(arr, n, k):while 2 * k + 1 < n:j = 2 * k + 1if j + 1 < n and arr[j + 1] < arr[j]:j += 1if arr[k] <= arr[j]:breakarr[k], arr[j] = arr[j], arr[k]k = jdef shiftDown2(arr, n, k):smallest, l, r = k, 2 * k + 1, 2 * k + 2while l < n:if arr[l] < arr[smallest]:smallest = lif r < n and arr[r] < arr[smallest]:smallest = rif smallest == k:breakelse:arr[k], arr[smallest] = arr[smallest], arr[k]k = smallestl, r = 2 * k + 1, 2 * k + 2def heapSort(arr):n = len(arr)heapify(arr)print("堆化：", arr)for i in range(n - 1):arr[n - i - 1], arr[0] = arr[0], arr[n - i - 1]# print("交換最小值后：",arr)shiftDown(arr, n - i - 1, 0)# print("調整后：",arr)arr = [12, 11, 13, 5, 6, 7, 9, 234, 23, 123, 45] heapSort(arr) print("排序后：", arr)

運行結果：

這兩種方式有不同特點，還是挺易于理解的。

·
·
·

希爾排序

大家可以參考這里：
Python 希爾排序

拓撲排序

大家可以參考這里：
Python 拓撲排序

總結

以上是生活随笔為你收集整理的python学习-综合练习七（二分查找（递归）、线性查找、插入排序、快速排序、选择排序、冒泡排序、归并排序、堆排序）-实例的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。