python經常使用算法學習（3）——排序查找
1，什麼是算法的時間和空間複雜度
算法（Algorithm）是指用來操做數據，解決程序問題的一組方法，對於同一個問題，使用不一樣的算法，也許最終獲得的結果是同樣的，可是在過程當中消耗的資源和時間卻會有很大的區別。html
那麼咱們應該如何去衡量不一樣算法之間的優劣呢？git
主要仍是從算法所佔用的時間和空間兩個維度取考量。github
- 時間維度：是指執行當前算法所消耗的時間，咱們一般使用時間複雜度來描述。
- 空間維度：是指執行當前算法須要佔用多少內存空間，咱們一般用空間複雜度來描述
所以，評價一個算法的效率主要是看它的時間複雜度和空間複雜度狀況，然而，有的時候時間和空間卻又是魚與熊掌，不可兼得，那麼咱們就須要從中去取一個平衡點。算法
下面分別學習一下時間複雜度和空間複雜度的計算方式。數組
1.1 時間複雜度
咱們想要知道一個算法的時間複雜度，不少人首先想到的方法就是把這個算法程序運行一遍，那麼它所消耗的時間就天然而然的知道了。這種方法能夠嗎？固然能夠，不過它也有不少弊端。app
這種方式很是容易受運行環境的影響，在性能高的機器上跑出來的結果與在性能低的機器上跑的結果相差會很大。並且對測試時使用的數據規模也有很大關係。再者咱們再寫算法的時候，尚未辦法完整的去運行呢，所以，另外一種更爲通用的方法就出來了：大O符號表示法，即T(n) = O(f(n))。框架
咱們先看一個例子：dom
for(i=1; i<=n; ++i)
{
j = i;
j++;
}
經過大O符合表示法，這段代碼的時間複雜度爲O（n），爲何呢？函數
在大O符號表示法中，時間複雜度的公式是：T(n) = O( f(n) )，其中f(n)表示每行代碼執行次數之和，而O表示正比例關係，這個公式的全稱是：算法的漸進時間複雜度。性能
咱們繼續看上面的例子，假設每行代碼的執行時間都是同樣的，咱們用1顆粒時間來表示，那麼這個例子的第一行耗時是1個顆粒時間，第三行的執行時間是n個顆粒時間，第四行執行時間也是n個顆粒時間（第二行和第五航是符號，暫時忽略），那麼總時間就是1顆粒時間+n顆粒時間+n顆粒時間，即 T(n) = (1+2n)*顆粒時間，從這個結果能夠看出，這個算法的耗時是隨着n的變化而變化，所以，咱們能夠簡化的將這個算法的時間複雜度表示爲：T(n) = O(n)。
爲何能夠這麼去簡化呢，由於大O符號表示法並非用於來真實表明算法的執行時間的，它是用來表示代碼執行時間的增加變化趨勢的。
因此上面的例子中，若是n無限大的時候，T(n) = time(1+2n)中的常量1就沒有意義了，倍數2也意義不大。所以直接簡化爲T(n) = O(n) 就能夠了。
經常使用的時間複雜度量級有：
- 常數階O(1)
- 對數階O(N)
- 線性階O(logN)
- 線性對數階O(nlogN)
- 平方階O(n2)
- 立方階O（n3）
- K 次方階O（n^k）
- 指數階（2^n）
從上之下依次的時間複雜度愈來愈大，執行的效率愈來愈低。
下面選取一些較爲經常使用的來講一下。
1，常數階O(1)
不管代碼執行了多少行，只要是沒有循環等複雜結構，那這個代碼的時間複雜度就都是O(1)，如：
int i = 1; int j = 2; ++i; j++; int m = i + j;
上述代碼在執行的時候，它消耗的時候並不隨着某個變量的增加而增加，那麼不管這類代碼有多長，即便有幾萬幾十萬行，均可以用O(1)來表示它的時間複雜度。
2，對數階O(N)
for(i=1; i<=n; ++i)
{
j = i;
j++;
}
這段代碼，for循環裏面的代碼會執行N遍，所以它消耗的時間是隨着n的變化而變化的，所以這類代碼均可以用O(n)來表示它的時間複雜度。
3，線性階O(logN)
先看代碼
int i = 1;
while(i<n)
{
i = i * 2;
}
從上面代碼能夠看到，在while循環裏面，每次都將 i 乘以 2，乘完以後，i 距離 n 就愈來愈近了。咱們試着求解一下，假設循環x次以後，i 就大於 2 了，此時這個循環就退出了，也就是說 2 的 x 次方等於 n，那麼 x = log2^n
也就是說當循環 log2^n 次之後，這個代碼就結束了。所以這個代碼的時間複雜度爲：O(logn)
4，線性對數階O(nlogN)
線性對數階O(nlogN) 其實很是容易理解，將時間複雜度爲O(logn)的代碼循環N遍的話，那麼它的時間複雜度就是 n * O(logN)，也就是了O(nlogN)。
就拿上面的代碼加一點修改來舉例：
for(m=1; m<n; m++)
{
i = 1;
while(i<n)
{
i = i *
5，平方階O(n2)
平方階O（n2）更容易理解了，若是把 O(n) 的代碼再嵌套循環一遍，它的時間複雜度就是 O(n²) 了。
舉例：
for(x=1; i<=n; x++)
{
for(i=1; i<=n; i++)
{
j = i;
j++;
}
}
這段代碼其實就是嵌套了2層n循環，它的時間複雜度就是 O(n*n)，即 O(n²)
若是將其中一層循環的n改爲m，即：
for(x=1; i<=m; x++)
{
for(i=1; i<=n; i++)
{
j = i;
j++;
}
}
那它的時間複雜度就變成了 O(m*n)
6，立方階O（n3）及K 次方階O（n^k）
參考上面O（n2）去理解就行了，至關於三層n循環，其餘的相似。
除此以外，其實還有 平均時間複雜度、均攤時間複雜度、最壞時間複雜度、最好時間複雜度 的分析方法，有點複雜，這裏就不展開了。
1.2 空間複雜度
空間複雜度：用來評估算法內存佔用大小的式子。
既然時間複雜度不是用來計算程序具體耗時的，那麼咱們也應該明白，空間複雜度也不是用來計算程序實際佔用的空間的。空間複雜度是對一個算法在運行過程當中臨時佔用存儲空間大小的一個量度，一樣反映的是一個趨勢，咱們用S(N)來定義。
空間複雜度的表示方式與時間複雜度徹底同樣：
- 算法使用了幾個變量：O(1)
- 算法使用了長度爲 n 的一維列表： O(n)
- 算法使用了m 行 n 列的二維列表：O(mn)
空間複雜度比較經常使用的有：O(1)，O(n)，O(n2)，咱們來看看：
空間複雜度O(1)
若是算法執行所須要的臨時空間不隨着某個變量n的大小而變化，即此算法空間複雜度爲一個常量，能夠表示爲O（1）。
舉例：
int i = 1; int j = 2; ++i; j++; int m = i + j;
代碼中的i，j，m所分配的空間都不隨着處理數據量變化，所以他的空間複雜度S（n） = O(1)
空間複雜度O(n)
咱們先看一個代碼：
int[] m = new int[n]
for(i=1; i<=n; ++i)
{
j = i;
j++;
}
這段代碼中，第一行new了一個數組出來，這個數據佔用的大小爲n，這段代碼的2~6行，雖然有循環，可是沒有再分配新的空間，所以，這段代碼的空間複雜度主要看第一行便可，即S(n)=O(n)。
空間換時間：常會爲了追求時間複雜度而犧牲空間複雜度。
1.3 如何簡單快速的判斷算法複雜度
快速判斷算法複雜度（適用於絕大多數簡單狀況）：
- 肯定問題規模 n
- 循環減半過程 ——> logN
- k層關於 n 的循環——> nk
複雜狀況：根據算法執行過程判斷
2，經常使用的算法總結
2.1 遞歸
2.1.1 遞歸概念
遞歸的兩個特色：1:，調用自身 2，結束條件
舉個例子學習下面函數是否是遞歸：
# 這個是一個死遞歸，只調用自身，可是沒有結束條件
def func1(x):
print(x)
func1(x-1)
# 這個是一個死遞歸，看似有結束條件，可是卻沒法結束
def func2(x):
if x > 0:
print(x)
func2(x+1)
# 這是一個遞歸函數,知足調用自身，而且有結束條件
def func3(x):
if x > 0:
print(x)
func3(x-1)
# 這個也是一個遞歸，可是和func3有區別
def func4(x):
if x > 0:
func4(x-1)
print(x)
func3和func4的區別是什麼？
假設x爲3，那麼func3輸出的結果爲：3,2,1 而 func4輸出的結果爲： 1,2,3。
爲了方便理解，咱們利用以下圖：
2.1.2 遞歸實例：漢諾塔問題
問題描述：大梵天創造世界的時候作了三根金剛石柱子，在一根柱子上從上往下按照大小順序摞着64片黃金圓盤。大梵天命名婆羅門把圓盤從下面開始按大小順序從新擺放在另外一個柱子上。在小圓盤上不能放大圓盤，在三根柱子之間只能移動一個圓盤。64根柱子移動完畢之日，就是世界毀滅之時。
問題分析：
代碼實現：
def hanoi(x,a,b,c):
if x>0:
# 除了下面最大的盤子，剩下的盤子從a移動到b
hanoi(x-1,a,c,b)
# 把最大的盤子從a移到c
print('%s->%s'%(a,c))
# 把剩餘的盤子從b移到c
hanoi(x-1,b,a,c)
hanoi(3,'A','B','C')
# 計算次數
def cal_times(x):
num = 1
for i in range(x-1):
# print(i)
num = 2*num +1
print(num)
cal_times(3)
遞歸總結：
- 1，漢諾塔移動次數的遞推式： h(x) = 2h(x-1)+1
- 2，h(64) = 18446744073709551615
- 3，假設婆羅門每秒鐘搬一個盤子，則總共須要 5800億年
證實：爲何漢諾塔的計算次數是2n+1呢？
對於一個單獨的塔，能夠進行如下操做：
- 1：將最下方的塔的上方的全部塔移動到過渡柱子
- 2：將底塔移動到目標柱子
- 3：將過渡柱子上的其餘塔移動到目標柱子
因此f(3)=f(2)+1+f(2)=7
而後以此類推
- f(4)=f(3)+1+f(3)=15
- f(5)=f(4)+1+f(4)=31
- f(6)=f(5)+1+f(5)=63
- f(7)=f(6)+1+f(6)=127
- f(8)=f(7)+1+f(7)=255
- f(9)=f(8)+1+f(8)=511
f(x+1)=2*f(x)+1
再進一步，能夠獲得通項公式爲
f(x)=2^x-1
2.2 查找算法
查找：在一些數據元素中，經過必定的方法找出與給定關鍵字相同的數據元素的過程。
列表查找（線性表查找）：從列表中查找指定元素
- 輸入：列表，待查找元素
- 輸出：元素下標（未找到元素時通常返回None或 -1）
內置列表查找函數：index()
2.2.1 順序查找（Linear Search）
順序查找：也叫線性查找，從列表第一個元素開始，順序進行搜索，直到找到元素或搜索到列表最後一個元素爲止。
時間複雜度爲：O(n)
def linear_search(data_set, value):
for i in data_set:
if value == data_set[i]:
return i
return None
2.2.2 二分查找（Binary Search）
二分查找：又叫折半查找，從有序列表的初始候選區 li[0:n] 開始，經過對待查找的值與候選區中間值得比較，可使候選區減小一半。
時間複雜度：O(logN)
def binary_search(data_list, val):
low = 0 # 最小數下標
high = len(data_list) - 1 # 最大數下標
while low <= high:
mid = (low + high) // 2 # 中間數下標
if data_list[mid] == val: # 若是中間數下標等於val, 返回
return mid
elif data_list[mid] > val: # 若是val在中間數左邊, 移動high下標
high = mid - 1
else: # 若是val在中間數右邊, 移動low下標
low = mid + 1
else:
return None # val不存在, 返回None
ret = binary_search(list(range(1, 10)), 3)
print(ret)
2.3 列表排序算法
排序：將一組「無序」的記錄序列調整爲「有序」 的記錄序列。
列表排序：將無序列表變爲有序列表
- 輸入：列表
- 輸出：有序列表
升序與降序
內置排序算法：sort()
2.3.1 常見排序算法
以下圖所示：
部分排序算法的時間複雜度和空間複雜度及其穩定性以下：
2.3.2 冒泡排序（Bubble Sort）
冒泡排序：像開水燒氣泡同樣，把最大的元素冒泡到最上面。一趟就是把最大的冒到最上面。冒到最上面的區域叫有序區。下面叫無序區。
列表每兩個相鄰的數，若是前面比後面大，則交換這兩個數。
一趟排序完成後，則無序區減小一個數，有序區增長一個數。
代碼關鍵點：趟，無序區範圍
時間複雜度：O(n2)
def bubble_sort(li):
for i in range(len(li)-1):
for j in range(len(li)-1-i):
if li[j] > li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
return li
冒泡排序降序排列：
# 降序排列
import random
def bubble_sort(li):
for i in range(len(li)-1): # 第 i 趟
for j in range(len(li)-1-i):
if li[j] < li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
li = [random.randint(0, 10) for i in range(10)]
print(li)
bubble_sort(li)
print(li)
'''
[5, 2, 10, 5, 5, 2, 5, 4, 3, 2]
[10, 5, 5, 5, 5, 4, 3, 2, 2, 2]
'''
固然也能夠打印每一趟，看看冒泡排序的過程：
# 升序排列，打印每一趟，看看其過程
def bubble_sort(li):
for i in range(len(li)-1): # 第 i 趟
for j in range(len(li)-1-i):
if li[j] > li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
print(li)
li = [9,8,7,6,5,4,3,2,1]
print('origin:',li)
bubble_sort(li)
'''
origin: [9, 8, 7, 6, 5, 4, 3, 2, 1]
[8, 7, 6, 5, 4, 3, 2, 1, 9]
[7, 6, 5, 4, 3, 2, 1, 8, 9]
[6, 5, 4, 3, 2, 1, 7, 8, 9]
[5, 4, 3, 2, 1, 6, 7, 8, 9]
[4, 3, 2, 1, 5, 6, 7, 8, 9]
[3, 2, 1, 4, 5, 6, 7, 8, 9]
[2, 1, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
'''
冒泡排序的最差狀況，即每次都交互順序的狀況下，時間複雜度爲O(n**2)。
存在一個最好狀況就是列表原本就是排好序，因此能夠加一個優化，也就是一個標誌位，若是沒有出現交換的狀況，說明列表已經有序，能夠直接結束算法，則直接return。
def optimize_bubble_sort(li):
for i in range(len(li)-1):
exchange = False
for j in range(len(li)-1-i):
li[j],li[j+1] = li[j+1],li[j]
exchange =True
if not exchange:
return li
return li
2.3.3 選擇排序（Select Sort）
一趟排序記錄最小的數，放到第一個位置
再一趟排序記錄記錄列表無序區最小的數，放到第二個位置。。。。
算法的關鍵點：有序區和無序區，無序區最小數的位置。
先看一個簡單的選擇排序
def select_sort_simple(li):
li_new = []
for i in range(len(li)):
min_val = min(li)
li_new.append(min_val)
li.remove(min_val)
return li_new
li = [4,3,2,1]
print(select_sort_simple(li))
# [1, 2, 3, 4]
咱們會發現首先他生成了兩個列表，那麼就佔用了兩分內存，而算法的思想則是能省則省，能摳則摳，因此咱們須要改進一下。
def select_sort(li):
for i in range(len(li)-1): # i 是第幾趟
min_loc = i
for j in range(i+1, len(li)):
if li[j] < li[min_loc]:
min_loc = j
li[i], li[min_loc] = li[min_loc], li[i]
return li
li = [1,2,3,4]
print(select_sort(li))
# [1, 2, 3, 4]
2.3.4 插入排序（Insertion Sort）
原理：把列表分紅有序區和無序區兩個部分。最初有序區只有一個元素。而後每次從無序區選擇一個元素，插入到有序區的位置，知道無序區變空。
def insert_sort(li):
for i in range(1, len(li)):
temp = li[i]
j = i - 1
if j > 0 and temp < li[j]: # 找到一個合適地位置插進去
li[j+1] = li[j]
j -= 1
li[j+1] = temp
return li
簡單形象的一張圖：
時間複雜度是 O(n2)
若是目標是 n 個元素的序列升序排列，那麼採用插入排序存在最好狀況和最壞的狀況。最好狀況就是，序列已是升序排列了，在這種狀況下，須要進行的比較操做須要（n-1）次便可。最壞的狀況就是序列是降序排列，那麼此時須要進行的比較共有 n(n-1)/2次。插入排序的賦值操做時比較操做的次數加上 （n-1）次。平均來講插入排序算法的時間複雜度爲O(n^2)，於是插入排序不適合對於數據量比較大的排序應用。可是，若是須要排序的數據量很小，例如量級小於千，那麼插入排序仍是一個不錯的選擇。
2.3.5 快速排序
原理：讓指定的元素歸位，所謂歸位，就是放到他應該放的位置（左邊的元素比他小，右邊的元素比他大），而後對每一個元素歸位，就完成了排序。
能夠參考下面動圖來理解代碼：
左邊空位置，從右邊找，右邊空位置，從左邊找。當左邊和右邊重合的時候，就是mid。
下圖來自百度百科
快速排序——框架函數
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)
完整代碼以下：
def partition(data, left, right):
# 把左邊第一個元素賦值給tmp，此時left指向空
tmp = data[left]
# 若是左右兩個指針不重合，則繼續
while left < right:
while left < right and data[right] >= tmp:
right -= 1 # 右邊的指標往左走一步
# 若是right指向的元素小於tmp，就放到左邊目前爲空的位置
data[left] = data[right]
print('left:', li)
while left < right and data[left] <= tmp:
left += 1
# 若是left指向的元素大於tmp，就交換到右邊目前爲空的位置
data[right] = data[left]
print('right:', li)
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
li = [5, 7, 4, 6, 3, 1, 2, 9, 8]
print('start:', li)
partition(li, 0, len(li) - 1)
print('end:', li)
'''
start: [5, 7, 4, 6, 3, 1, 2, 9, 8]
left: [2, 7, 4, 6, 3, 1, 2, 9, 8]
right: [2, 7, 4, 6, 3, 1, 7, 9, 8]
left: [2, 1, 4, 6, 3, 1, 7, 9, 8]
right: [2, 1, 4, 6, 3, 6, 7, 9, 8]
left: [2, 1, 4, 3, 3, 6, 7, 9, 8]
right: [2, 1, 4, 3, 3, 6, 7, 9, 8]
end: [2, 1, 4, 3, 5, 6, 7, 9, 8]
'''
正常的狀況，快排的複雜度是O(nlogn)
快排存在一個最壞狀況，就是每次歸位，都不能把列表分紅兩部分，此時複雜度就是O(n2)了，若是要避免設計成這種最壞狀況，能夠在取第一個數的時候不要取第一個了，而是取一個列表中的隨機數。
2.3.6 堆排序（Heap Sort）
本質是使用大根堆或小根堆來對一個數組進行排序。因此首先要理解樹的概念。
關於樹的理解請參考博客：http://www.javashuo.com/article/p-huspuiuc-ba.html
堆簡單來講：一種特殊的徹底二叉樹結構
- 大根堆：一種徹底二叉樹，知足任一節點都比其孩子節點大
- 小根堆：一種徹底二叉樹，知足任一節點都比其孩子節點小
堆排序——堆的向下調整性質
假設根節點的左右子樹都是堆，但根節點不知足堆的性質，能夠經過一次向下的調整來將其變成一個堆
當根節點的左右子樹都是堆時，能夠經過一次向下的調整來將其變換成一個堆。
堆排序過程
1，創建堆
2，獲得堆頂元素，爲最大元素
3，去掉堆頂，將堆最後一個元素放到堆頂，此時能夠經過一次調整從新使堆有序。
4，堆頂元素爲第二大元素
5，重複步驟3，知道堆變爲空
代碼以下：
def sift(data, low, high):
i = low
j = 2*i+1
tmp = data[i]
while j <=high:
if j < high and data[j] < data[j+1]:
j+=1
if tmp < data[j]:
data[i] = data[j]
i = j
j = 2*i+1
else:
break
data[i] = tmp
def heap_li(li):
n = len(li)
for i in range((n - 2) // 2, -1, -1):
# i表示建堆的時候調整的部分的跟的下標
sift(li, i, n - 1)
# 建堆完成了
print('建堆完成後的列表：',li)
for i in range(n-1, -1, -1):
# i 指向當前堆的最後一個元素
li[0], li[i] = li[i], li[0]
sift(li, 0, i-1) # i-1是新的high
print(li)
li = [i for i in range(12)]
import random
random.shuffle(li)
print(li)
heap_li(li)
print(li)
'''
[7, 2, 4, 3, 8, 9, 0, 5, 11, 6, 10, 1]
建堆完成後的列表： [11, 10, 9, 5, 8, 4, 0, 2, 3, 6, 7, 1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
'''
堆排序應用——topK問題
問題描述：如今有n個數，設計算法獲得前k大的數（ k<n）
解決思路：
- 排序後切片 時間複雜度爲：O(nlogn)
- 排序（選擇，插入，冒泡） 時間複雜度爲：O(mn)
- 堆排序思路 時間複雜度爲：O(mlogn)
代碼以下：
def sift(li, low, high):
i = low
j = 2 * i + 1
tmp = li[low]
while j <= high:
if j + 1 <= high and li[j + 1] < li[j]:
j = j + 1
if li[j] < tmp:
li[i] = li[j]
i = j
j = 2 * j + 1
else:
break
li[i] = tmp
def topk(li, k):
heap = li[0:k]
for i in range((k - 2) // 2, -1, -1):
sift(heap, i, k - 1)
# 1,建堆
for i in range(k, len(li) - 1):
if li[i] > heap[0]:
heap[0] = li[i]
sift(heap, 0, k - 1)
# 2，遍歷
for i in range(k - 1, -1, -1):
heap[0], heap[i] = heap[i], heap[0]
sift(heap, 0, i - 1)
# 3，出數
return heap
import random
li = list(range(1000))
random.shuffle(li)
print(topk(li, 10))
2.3.7 歸併排序（Merge Sort）
歸併：假設如今的列表分兩段有序，如何將其合成爲一個有序列表，這種操做叫作一次歸併。
以下圖所示：虛線分開，兩個箭頭分別指向列表的第一個元素。而後從左邊開始比較兩邊的元素，小的出列。而後繼續循環，這樣就排出來一個有序列表。
應用到排序就是把列表分紅一個元素一個元素的，一個元素固然是有序的，將有序列表一個一個合併，列表愈來愈大，最終合併成一個有序的列表。
歸併排序如圖所示：
歸併排序代碼以下：
def merge(li, low, mid, high):
i = low # i爲左邊列表開頭元素的座標
j = mid + 1 # j爲右邊列表開頭元素的座標
ltmpd = [] # 臨時列表
# 只要兩邊都有數
while i <= mid and j <= high:
if li[i] < li[j]:
ltmpd.append(li[i])
i += 1
else:
ltmpd.append(li[j])
j += 1
# while執行完，確定有一部分沒數字了，就是兩個箭頭確定有一個指向沒數了
while i <= mid:
ltmpd.append(li[i])
i += 1
while j <= high:
ltmpd.append(li[j])
j += 1
li[low:high + 1] = ltmpd
# return ltmpd
def merge_sort(li, low, high):
if low < high: # 列表中至少兩個元素，遞歸
mid = (low + high) // 2
merge_sort(li, low, mid)
merge_sort(li, mid + 1, high)
merge(li, low, mid, high)
li = list(range(10))
import random
random.shuffle(li)
print(li)
merge_sort(li, 0, len(li)-1)
print(li)
歸併排序的時間複雜度：O(nlogn）
歸併排序的空間複雜度：O(n)
2.3.8 快速排序，堆排序，歸併排序三種算法的總結
1，三種排序算法的時間複雜度都是O(nlogn)
2，通常狀況下，就運行時間而言：快速排序 < 歸併排序 < 堆排序
3，三種排序算法的缺點
- 快速排序：極端狀況下排序效率低
- 歸併排序：須要額外的內存開銷
- 堆排序：在快的排序算法中相對較慢
2.3.9 希爾排序（Shell Sort）
希爾排序（Shell Sort）是一種分組插入排序算法。
其算法步驟以下：
- 首先取一個整數 d1=n/2，將元素分爲 d1個組，每組相鄰量元素之間距離爲 d1，在各組內進行直接插入排序；
- 而後取第二個整數 d2=d1/2，重複上述分組排序過程，知道 di=1，即全部元素在同一組內進行直接插入排序；
- 最後希爾排序每趟並不使某些元素有序，而是使總體數據愈來愈接近有序，最後一趟排序使得全部數據有序
圖解以下：
1，數組（列表）以下：
2，d=4（即d=len(li)/2）:
3，d=2：
4，d=1：
在wiki查找地址以下：https://en.wikipedia.org/wiki/Shellsort#Gap_sequences
希爾排序的時間複雜度討論比較複雜，而且和選取的gap序列有關。
2.3.10 計數排序（Count Sort）
簡單來講以下圖所示：
出現那個數，就給那個數的數量加一。
代碼以下：
def count_sort(li, max_count=100):
count = [0 for _ in range(max_count+1)]
for val in li:
count[val] += 1
li.clear() # 原列表清空，這樣就不用建新列表，省內存
for ind, val in enumerate(count):
for i in range(val):
li.append(ind)
import random
li = [random.randint(0, 19) for _ in range(30)]
print(li)
count_sort(li)
print(li)
'''
[1, 4, 13, 6, 19, 4, 9, 14, 10, 15, 7, 1, 1, 9, 3, 8, 17, 3, 18, 1, 8, 17, 14, 2, 10, 0, 5, 8, 12, 15]
[0, 1, 1, 1, 1, 2, 3, 3, 4, 4, 5, 6, 7, 8, 8, 8, 9, 9, 10, 10, 12, 13, 14, 14, 15, 15, 17, 17, 18, 19]
'''
對列表進行排序，已知列表中的數範圍都在0到100之間，設計時間複雜度爲O(n)的算法。就可使用此算法，即便列表長度大約爲100萬，雖然列表長度很大，可是數據量很小，會有大量的重複數據，咱們能夠考慮對這100個數進行排序。
2.3.11 桶排序(Bucket Sort)
桶排序也叫計數排序，簡單來講，就是將數據集裏面全部元素按順序列舉出來，而後統計元素出現的次數，最後按照順序輸出數據集裏面的元素。
在計數排序中，若是元素的範圍比較大（好比在1到1億之間），如何改造算法？
桶排序（Bucket Sort）：首先將元素分在不一樣的桶中，在對每一個桶中的元素排序。
如上圖，列表爲 [29, 25, 3, 49, 9, 37, 21, 43]排序，咱們知道數組的範圍是0~49，咱們將其分爲5個桶，而後放入數字，一次對桶中的元素排序。
桶排序的表現取決於數據的分佈。也就是須要對不一樣數據排序採起不一樣的分桶策略。
- 平均狀況時間複雜度爲：O(n+k)
- 最壞狀況時間複雜度爲：O(n2k)
- 空間複雜度爲：O(nk)
代碼以下：
#_*_coding:utf-8_*_
def bucket_sort(li, n=100, max_num=10000):
buckets = [[] for _ in range(n)] # 建立桶
for var in li:
# 0 -》 0， 86
i = min(var // (max_num // n), n-1) # i表示var放到幾號桶裏
buckets[i].append(var) # 把var加入到桶裏
# [0, 2, 4]
# 保持桶內的順序
for j in range(len(buckets[i])-1, 0, -1):
if buckets[i][j] < buckets[i][j-1]:
buckets[i][j], buckets[i][j-1] = buckets[i][j-1], buckets[i][j]
else:
break
sorted_li = []
for buc in buckets:
sorted_li.extend(buc)
return sorted_li
import random
if __name__ == '__main__':
li = [random.randint(0, 10000) for i in range(10000)]
# print(li)
li = bucket_sort(li)
print(li)
2.3.12 基數排序
多關鍵字排序：加入如今有一個員工表，要求按照薪資排序，年齡相同的員工按照年齡排序。
方法：先按照年齡進行排序，再按照薪資進行穩定的排序。
好比對 [32, 13, 94, 52, 17, 54, 93] 排序是否能夠當作多關鍵字排序？
實現示例以下：
1，首先按照個位分桶：
2，按照個位數分好,桶，而後擺回原位
3，按照十位數進行分桶，而後將桶裏的數排序
基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不一樣的數字，而後按照每一個位數分別比較。因爲整數也能夠表達字符串（好比名稱或日期）和特定格式的浮點數，因此基礎排序也不是隻能使用於整數。
基數排序的時間複雜度爲：O(kn)
基數排序的空間複雜度爲：O(k+n)
基數排序中 k 表示數字位數
因爲基數排序使用了桶排序，因此空間複雜度和桶排序的空間複雜度是同樣的。
代碼以下：
def list_to_buckets(li, base, iteration):
buckets = [[] for _ in range(base)]
for number in li:
digit = (number // (base ** iteration)) % base
buckets[digit].append(number)
return buckets
def buckets_to_list(buckets):
return [x for bucket in buckets for x in bucket]
def radix_sort(li, base=10):
maxval = max(li)
it = 0
while base ** it <= maxval:
li = buckets_to_list(list_to_buckets(it, base, it))
it += 1
return li
2.3.13 基數排序 VS 計數排序 VS 桶排序
這三種排序算法都利用了桶的概念，但對於桶的使用方法上有明顯差別。
- 基數排序：根據鍵值的每位數字來分配桶
- 計數排序：每一個桶只存儲單一鍵值
- 桶排序：每一個桶存儲必定範圍內的數值
三，幾道查找排序習題
這一節是對前面學習的算法的應用，也就是習題練習。
1，給兩個字符串s和t，判斷 t是否爲s的從新排列後組成的單詞
s = 'anagram' t='nagaram' return true
s='rat', t='car', return false
兩種方法一種直接使用Python的list排序，固然這種時間複雜度可能高一些。另外一種方法使用字典記錄list中出現字母的次數。代碼以下：
def isAnagram0(s, t):
return sorted(list(s)) == sorted(list(t))
def isAnagram1(s, t):
dict1 = [] # ['a':1, 'b':2]
dict2 = []
for ch in s:
dict1[ch] = dict1.get(ch, 0) + 1
for ch in t:
dict2[ch] = dict2.get(ch, 0) + 1
return dict1 == dict2
2，給定一個 m*n 的二維列表，查找一個數是否存在，列表有下列特性：
-
每一行的列表從左到右已經排序好
-
每一行第一個數比上一行最後一個數大
思路以下：有兩個方法，第一個是暴力遍歷法，可是這種時間複雜度會很高，而相對來講改進的方法是二分查找。
實現代碼以下：
def searchMatrix(matrix, target):
for line in matrix:
if target in line:
return True
return False
def searchMatrix1(matrix, target):
h = len(matrix)
if h == 0:
return False # h=0 即爲 []
# 固然也出現一種可能就是 [[],[]]
w = len(matrix[0])
if w == 0:
return False
left = 0
right = w * h - 1
# 直接使用二分查找的代碼
while left <= right:
mid = (left + right) // 2
i = mid // w
j = mid % w
if matrix[i][j] == target:
return True
elif matrix[i][j] > target:
right = mid - 1
else:
left = mid + 1
else:
return False
matrix = [[1, 2, 3], [5, 6, 7], [9, 12, 23]]
target = 32
res = searchMatrix1(matrix, target)
print(res)
3，給定一個列表和一個整數，設計算法找到兩個數的下標，使得兩個數之和爲給定的整數。保證確定僅有一個結果。例如，列表[1,2,5,4] 與目標整數3,1+2=3，結果爲（0,1）
代碼以下：
def TwoSum(nums, target):
'''
:param nums: nums是表明一個list
:param target: target是一個數
:return: 結果返回的時兩個數的下標
'''
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
return (i, j)
def TwoSum1(nums, target):
# 新建一個空字典用來保存數值及在其列表中對應的索引
dict1 = {}
for i in range(len(nums)):
# 相減獲得另外一個數值
num = target - nums[i]
if num not in dict1:
dict1[nums[i]] = i
# 若是在字典中則返回
else:
return [dict1[num], i]
def binary_search(li,left, right, val):
while left <= right: # 候選區有值
mid = (left + right) // 2
if li[mid] == val:
return mid
elif li[mid] < val:
left = mid +1
else:
right = mid -1
else:
return None
def TwoSum2(nums, target):
for i in range(len(nums)):
a = nums[i]
b = target - a
if b >=a:
j = binary_search(nums, i+1, len(nums)-1, a)
else:
j = binary_search(nums, 0, i-1, b)
return (i, j)
傳送門：代碼的GitHub地址：https://github.com/LeBron-Jian/BasicAlgorithmPractice
- 1. 經常使用排序查找算法
- 2. 經常使用算法之---排序 和 查找
- 3. 經常使用查找、排序算法的性能總結
- 4. java中經常使用的排序和查找算法
- 5. 經常使用查找和排序
- 6. 算法學習--排序與查找
- 7. 算法_經常使用排序算法
- 8. 算法3：最經常使用的排序——快速排序
- 9. 經常使用排序和查找算法的原理及python實現
- 10. Java-經常使用查找算法
- 更多相關文章...
- • Eclipse 查找 - Eclipse 教程
- • ADO 排序 - ADO 教程
- • 算法總結-二分查找法
- • 算法總結-歸併排序
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 經常使用排序查找算法
- 2. 經常使用算法之---排序 和 查找
- 3. 經常使用查找、排序算法的性能總結
- 4. java中經常使用的排序和查找算法
- 5. 經常使用查找和排序
- 6. 算法學習--排序與查找
- 7. 算法_經常使用排序算法
- 8. 算法3：最經常使用的排序——快速排序
- 9. 經常使用排序和查找算法的原理及python實現
- 10. Java-經常使用查找算法