冒泡排序(英語:Bubble Sort)是一種簡單的排序算法。它重複地遍歷要排序的數列,一次比較兩個元素,若是他們的順序錯誤就把他們交換過來。遍歷數列的工做是重複地進行直到沒有再須要交換,也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。python
冒泡排序算法的運做以下:算法
交換過程圖示(第一次):shell
代碼以下:api
def bubble_sort(li):
for i in range(len(li) - 1):
for j in range(len(li) - i - 1):
if li[j] > li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
return li
list1 = [15, 66, 20, 350, 464, 88, 995, 100]
print(bubble_sort(list1))
效果:數組
選擇排序(Selection sort)是一種簡單直觀的排序算法。它的工做原理以下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,而後,再從剩餘未排序元素中繼續尋找最小(大)元素,而後放到已排序序列的末尾。以此類推,直到全部元素均排序完畢。緩存
選擇排序的主要優勢與數據移動有關。若是某個元素位於正確的最終位置上,則它不會被移動。選擇排序每次交換一對元素,它們當中至少有一個將被移到其最終位置上,所以對n個元素的表進行排序總共進行至多n-1次交換。在全部的徹底依靠交換去移動元素的排序方法中,選擇排序屬於很是好的一種。數據結構
排序過程:app
紅色表示當前最小值,黃色表示已排序序列,藍色表示當前位置。性能
def selection_sort(alist): n = len(alist) # 須要進行n-1次選擇操做 for i in range(n-1): # 記錄最小位置 min_index = i # 從i+1位置到末尾選擇出最小數據 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] alist = [54,226,93,17,77,31,44,55,20] selection_sort(alist) print(alist)
插入排序(英語:Insertion Sort)是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列,對於未排序數據,在已排序序列中從後向前掃描,找到相應位置並插入。插入排序在實現上,在從後向前掃描過程當中,須要反覆把已排序元素逐步向後挪位,爲最新元素提供插入空間。ui
def insert_sort(alist): # 從第二個位置,即下標爲1的元素開始向前插入 for i in range(1, len(alist)): # 從第i個元素開始向前比較,若是小於前一個元素,交換位置 for j in range(i, 0, -1): if alist[j] < alist[j-1]: alist[j], alist[j-1] = alist[j-1], alist[j] alist = [54,26,93,17,77,31,44,55,20] insert_sort(alist) print(alist)
快速排序(英語:Quicksort),又稱劃分交換排序(partition-exchange sort),經過一趟排序將要排序的數據分割成獨立的兩部分,其中一部分的全部數據都比另一部分的全部數據都要小,而後再按此方法對這兩部分數據分別進行快速排序,整個排序過程能夠遞歸進行,以此達到整個數據變成有序序列。
步驟爲:
遞歸的最底部情形,是數列的大小是零或一,也就是永遠都已經被排序好了。雖然一直遞歸下去,可是這個算法總會結束,由於在每次的迭代(iteration)中,它至少會把一個元素擺到它最後的位置去。
def quick_sort(alist, start, end): """快速排序""" # 遞歸的退出條件 if start >= end: return # 設定起始元素爲要尋找位置的基準元素 mid = alist[start] # low爲序列左邊的由左向右移動的遊標 low = start # high爲序列右邊的由右向左移動的遊標 high = end while low < high: # 若是low與high未重合,high指向的元素不比基準元素小,則high向左移動 while low < high and alist[high] >= mid: high -= 1 # 將high指向的元素放到low的位置上 alist[low] = alist[high] # 若是low與high未重合,low指向的元素比基準元素小,則low向右移動 while low < high and alist[low] < mid: low += 1 # 將low指向的元素放到high的位置上 alist[high] = alist[low] # 退出循環後,low與high重合,此時所指位置爲基準元素的正確位置 # 將基準元素放到該位置 alist[low] = mid # 對基準元素左邊的子序列進行快速排序 quick_sort(alist, start, low-1) # 對基準元素右邊的子序列進行快速排序 quick_sort(alist, low+1, end) alist = [54,26,93,17,77,31,44,55,20] quick_sort(alist,0,len(alist)-1) print(alist)
從一開始快速排序平均須要花費O(n log n)時間的描述並不明顯。可是不難觀察到的是分區運算,數組的元素都會在每次循環中走訪過一次,使用O(n)的時間。在使用結合(concatenation)的版本中,這項運算也是O(n)。
在最好的狀況,每次咱們運行一次分區,咱們會把一個數列分爲兩個幾近相等的片斷。這個意思就是每次遞歸調用處理一半大小的數列。所以,在到達大小爲一的數列前,咱們只要做log n次嵌套的調用。這個意思就是調用樹的深度是O(log n)。可是在同一層次結構的兩個程序調用中,不會處理到原來數列的相同部分;所以,程序調用的每一層次結構總共所有僅須要O(n)的時間(每一個調用有某些共同的額外耗費,可是由於在每一層次結構僅僅只有O(n)個調用,這些被概括在O(n)係數中)。結果是這個算法僅需使用O(n log n)時間。
希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序,是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。該方法因DL.Shell於1959年提出而得名。 希爾排序是把記錄按下標的必定增量分組,對每組使用直接插入排序算法排序;隨着增量逐漸減小,每組包含的關鍵詞愈來愈多,當增量減至1時,整個文件恰被分紅一組,算法便終止。
希爾排序的基本思想是:將數組列在一個表中並對列分別進行插入排序,重複這過程,不過每次用更長的列(步長更長了,列數更少了)來進行。最後整個表就只有一列了。將數組轉換至表是爲了更好地理解這算法,算法自己仍是使用數組進行排序。
例如,假設有這樣一組數[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ],若是咱們以步長爲5開始進行排序,咱們能夠經過將這列表放在有5列的表中來更好地描述算法,這樣他們就應該看起來是這樣(豎着的元素是步長組成):
13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10
而後咱們對每列進行排序:
10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45
將上述四行數字,依序接在一塊兒時咱們獲得:[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。這時10已經移至正確位置了,而後再以3爲步長進行排序:
10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45
排序以後變爲:
10 14 13 25 23 33 27 25 59 39 65 73 45 94 82 94
最後以1步長進行排序(此時就是簡單的插入排序了)
def shell_sort(alist): n = len(alist) # 初始步長 gap = n / 2 while gap > 0: # 按步長進行插入排序 for i in range(gap, n): j = i # 插入排序 while j>=gap and alist[j-gap] > alist[j]: alist[j-gap], alist[j] = alist[j], alist[j-gap] j -= gap # 獲得新的步長 gap = gap / 2 alist = [54,26,93,17,77,31,44,55,20] shell_sort(alist) print(alist)
歸併排序是採用分治法的一個很是典型的應用。歸併排序的思想就是先遞歸分解數組,再合併數組。
將數組分解最小以後,而後合併兩個有序數組,基本思路是比較兩個數組的最前面的數,誰小就先取誰,取了後相應的指針就日後移一位。而後再比較,直至一個數組爲空,最後把另外一個數組的剩餘部分複製過來便可。
def merge(li, low, mid, high):
i = low
j = mid + 1
ltmp = []
while i <= mid and j <= high:
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 <= high:
ltmp.append(li[j])
j += 1
li[low:high+1] = ltmp
def _mergesort(li, low, high):
if low < high:
mid = (low + high) // 2
_mergesort(li,low, mid)
_mergesort(li, mid+1, high)
merge(li, low, mid, high)
在這裏首先要先解釋一下什麼是堆,堆棧是計算機的兩種最基本的數據結構。堆的特色就是FIFO(first in first out)先進先出,這裏的話我以爲能夠理解成樹的結構。堆在接收數據的時候先接收的數據會被先彈出。
棧的特性正好與堆相反,是屬於FILO(first in/last out)先進後出的類型。棧處於一級緩存而堆處於二級緩存中。這個不是本文重點因此不作過多展開。
在這裏咱們借用wiki的定義來講明:
一般堆是經過一維數組來實現的。在陣列起始位置爲0的狀況中
(1)父節點i的左子節點在位置(2*i+1);
(2)父節點i的右子節點在位置(2*i+2);
(3)子節點i的父節點在位置floor((i-1)/2);
堆能夠分爲大根堆和小根堆,這裏用最大堆的狀況來定義操做:
(1)最大堆調整(MAX_Heapify):將堆的末端子節點做調整,使得子節點永遠小於父節點。這是核心步驟,在建堆和堆排序都會用到。比較i的根節點和與其所對應i的孩子節點的值。當i根節點的值比左孩子節點的值要小的時候,就把i根節點和左孩子節點所對應的值交換,當i根節點的值比右孩子的節點所對應的值要小的時候,就把i根節點和右孩子節點所對應的值交換。而後再調用堆調整這個過程,可見這是一個遞歸的過程。
(2)創建最大堆(Build_Max_Heap):將堆全部數據從新排序。建堆的過程其實就是不斷作最大堆調整的過程,從len/2出開始調整,一直比到第一個節點。
(3)堆排序(HeapSort):移除位在第一個數據的根節點,並作最大堆調整的遞歸運算。堆排序是利用建堆和堆調整來進行的。首先先建堆,而後將堆的根節點選出與最後一個節點進行交換,而後將前面len-1個節點繼續作堆調整的過程。直到將全部的節點取出,對於n個數咱們只須要作n-1次操做。
這裏用網上的一張直觀圖來感覺一下
def sift(data, low, high): i = low j = 2 * i + 1 tmp = data[i] while j <= high: #只要沒到子樹的最後 if j+1 <= high and data[j] < data[j + 1]: #若是有右孩子且比左孩子大 j += 1 #就把j指向右孩子 if tmp < data[j]:#若是領導不能幹 data[i] = data[j] #小領導上位 i = j j = 2 * i + 1 else: break data[i] = tmp def heap_sort(data): n = len(data) for i in range(n // 2 - 1, -1, -1): sift(data, i, n - 1) for i in range(n - 1, -1, -1): data[0], data[i] = data[i], data[0] sift(data, 0, i - 1)
搜索是在一個項目集合中找到一個特定項目的算法過程。搜索一般的答案是真的或假的,由於該項目是否存在。 搜索的幾種常見方法:順序查找、二分法查找、二叉樹查找、哈希查找
二分查找又稱折半查找,優勢是比較次數少,查找速度快,平均性能好;其缺點是要求待查表爲有序表,且插入刪除困難。所以,折半查找方法適用於不常常變更而查找頻繁的有序列表。首先,假設表中元素是按升序排列,將表中間位置記錄的關鍵字與查找關鍵字比較,若是二者相等,則查找成功;不然利用中間位置記錄將表分紅前、後兩個子表,若是中間位置記錄的關鍵字大於查找關鍵字,則進一步查找前一子表,不然進一步查找後一子表。重複以上過程,直到找到知足條件的記錄,使查找成功,或直到子表不存在爲止,此時查找不成功。
def binary_search(alist, item): first = 0 last = len(alist)-1 while first<=last: midpoint = (first + last)/2 if alist[midpoint] == item: return True elif item < alist[midpoint]: last = midpoint-1 else: first = midpoint+1 return False testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,] print(binary_search(testlist, 3)) print(binary_search(testlist, 13)) (遞歸實現) def binary_search(alist, item): if len(alist) == 0: return False else: midpoint = len(alist)//2 if alist[midpoint]==item: return True else: if item<alist[midpoint]: return binary_search(alist[:midpoint],item) else: return binary_search(alist[midpoint+1:],item) testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,] print(binary_search(testlist, 3)) print(binary_search(testlist, 13))
python