1，什么是算法的時(shí)間和空間復(fù)雜度

　　算法(Algorithm)是指用來(lái)操作數(shù)據(jù)，解決程序問(wèn)題的一組方法，對(duì)于同一個(gè)問(wèn)題，使用不同的算法，也許最終得到的結(jié)果是一樣的，但是在過(guò)程中消耗的資源和時(shí)間卻會(huì)有很大的區(qū)別。

　　那么我們應(yīng)該如何去衡量不同算法之間的優(yōu)劣呢？

　　主要還是從算法所占用的時(shí)間和空間兩個(gè)維度取考量。

• 時(shí)間維度：是指執(zhí)行當(dāng)前算法所消耗的時(shí)間，我們通常使用時(shí)間復(fù)雜度來(lái)描述。
• 空間維度：是指執(zhí)行當(dāng)前算法需要占用多少內(nèi)存空間，我們通常用空間復(fù)雜度來(lái)描述

　　因此，評(píng)價(jià)一個(gè)算法的效率主要是看它的時(shí)間復(fù)雜度和空間復(fù)雜度情況，然而，有的時(shí)候時(shí)間和空間卻又是魚與熊掌，不可兼得，那么我們就需要從中去取一個(gè)平衡點(diǎn)。

　　下面分別學(xué)習(xí)一下時(shí)間復(fù)雜度和空間復(fù)雜度的計(jì)算方式。

1.1 時(shí)間復(fù)雜度

　　我們想要知道一個(gè)算法的時(shí)間復(fù)雜度，很多人首先想到的方法就是把這個(gè)算法程序運(yùn)行一遍，那么它所消耗的時(shí)間就自然而然的知道了。這種方法可以嗎？當(dāng)然可以，不過(guò)它也有很多弊端。

　　這種方式非常容易受運(yùn)行環(huán)境的影響，在性能高的機(jī)器上跑出來(lái)的結(jié)果與在性能低的機(jī)器上跑的結(jié)果相差會(huì)很大。而且對(duì)測(cè)試時(shí)使用的數(shù)據(jù)規(guī)模也有很大關(guān)系。再者我們?cè)賹懰惴ǖ臅r(shí)候，還沒(méi)有辦法完整的去運(yùn)行呢，因此，另一種更為通用的方法就出來(lái)了：大O符號(hào)表示法，即T(n) = O(f(n))。

　　我們先看一個(gè)例子：

for(i=1; i<=n; ++i){???j = i;???j++;}

　　通過(guò)大O符合表示法，這段代碼的時(shí)間復(fù)雜度為O(n)，為什么呢？

　　在大O符號(hào)表示法中，時(shí)間復(fù)雜度的公式是：T(n) = O( f(n) )，其中f(n)表示每行代碼執(zhí)行次數(shù)之和，而O表示正比例關(guān)系，這個(gè)公式的全稱是：算法的漸進(jìn)時(shí)間復(fù)雜度。

　　 我們繼續(xù)看上面的例子，假設(shè)每行代碼的執(zhí)行時(shí)間都是一樣的，我們用1顆粒時(shí)間來(lái)表示，那么這個(gè)例子的第一行耗時(shí)是1個(gè)顆粒時(shí)間，第三行的執(zhí)行時(shí)間是n個(gè)顆粒時(shí)間，第四行執(zhí)行時(shí)間也是n個(gè)顆粒時(shí)間(第二行和第五航是符號(hào)，暫時(shí)忽略)，那么總時(shí)間就是1顆粒時(shí)間+n顆粒時(shí)間+n顆粒時(shí)間，即 T(n) = (1+2n)*顆粒時(shí)間，從這個(gè)結(jié)果可以看出，這個(gè)算法的耗時(shí)是隨著n的變化而變化，因此，我們可以簡(jiǎn)化的將這個(gè)算法的時(shí)間復(fù)雜度表示為：T(n) = O(n)。

　　為什么可以這么去簡(jiǎn)化呢，因?yàn)榇驩符號(hào)表示法并不是用于來(lái)真實(shí)代表算法的執(zhí)行時(shí)間的，它是用來(lái)表示代碼執(zhí)行時(shí)間的增長(zhǎng)變化趨勢(shì)的。

　　所以上面的例子中，如果n無(wú)限大的時(shí)候，T(n) = time(1+2n)中的常量1就沒(méi)有意義了，倍數(shù)2也意義不大。因此直接簡(jiǎn)化為T(n) = O(n) 就可以了。

常用的時(shí)間復(fù)雜度量級(jí)有：

• 常數(shù)階O(1)
• 對(duì)數(shù)階O(N)
• 線性階O(logN)
• 線性對(duì)數(shù)階O(nlogN)
• 平方階O(n2)
• 立方階O(n3)
• K 次方階O(n^k)
• 指數(shù)階(2^n)

　　從上之下依次的時(shí)間復(fù)雜度越來(lái)越大，執(zhí)行的效率越來(lái)越低。

　　下面選取一些較為常用的來(lái)說(shuō)一下。

1，常數(shù)階O(1)

　　無(wú)論代碼執(zhí)行了多少行，只要是沒(méi)有循環(huán)等復(fù)雜結(jié)構(gòu)，那這個(gè)代碼的時(shí)間復(fù)雜度就都是O(1)，如：

int?i = 1;int?j = 2;++i;j++;int?m = i + j;

　　上述代碼在執(zhí)行的時(shí)候，它消耗的時(shí)候并不隨著某個(gè)變量的增長(zhǎng)而增長(zhǎng)，那么無(wú)論這類代碼有多長(zhǎng)，即使有幾萬(wàn)幾十萬(wàn)行，都可以用O(1)來(lái)表示它的時(shí)間復(fù)雜度。

2，對(duì)數(shù)階O(N)

for(i=1; i<=n; ++i){???j = i;???j++;}

　　這段代碼，for循環(huán)里面的代碼會(huì)執(zhí)行N遍，因此它消耗的時(shí)間是隨著n的變化而變化的，因此這類代碼都可以用O(n)來(lái)表示它的時(shí)間復(fù)雜度。

3，線性階O(logN)

　　先看代碼

int?i = 1;while(i

　　從上面代碼可以看到，在while循環(huán)里面，每次都將 i 乘以 2，乘完之后，i 距離 n 就越來(lái)越近了。我們?cè)囍蠼庖幌?#xff0c;假設(shè)循環(huán)x次之后，i 就大于 2 了，此時(shí)這個(gè)循環(huán)就退出了，也就是說(shuō) 2 的 x 次方等于 n，那么 x = log2^n　　也就是說(shuō)當(dāng)循環(huán) log2^n 次以后，這個(gè)代碼就結(jié)束了。因此這個(gè)代碼的時(shí)間復(fù)雜度為：O(logn)

4，線性對(duì)數(shù)階O(nlogN)

　　線性對(duì)數(shù)階O(nlogN) 其實(shí)非常容易理解，將時(shí)間復(fù)雜度為O(logn)的代碼循環(huán)N遍的話，那么它的時(shí)間復(fù)雜度就是 n * O(logN)，也就是了O(nlogN)。

　　就拿上面的代碼加一點(diǎn)修改來(lái)舉例：

for(m=1; m

5，平方階O(n2)

　　平方階O(n2)更容易理解了，如果把 O(n) 的代碼再嵌套循環(huán)一遍，它的時(shí)間復(fù)雜度就是 O(n2) 了。　　舉例：

for(x=1; i<=n; x++){???for(i=1; i<=n; i++)????{???????j = i;???????j++;????}}

　　這段代碼其實(shí)就是嵌套了2層n循環(huán)，它的時(shí)間復(fù)雜度就是 O(n*n)，即 O(n2) 　　如果將其中一層循環(huán)的n改成m，即：

for(x=1; i<=m; x++){???for(i=1; i<=n; i++)????{???????j = i;???????j++;????}}

　　那它的時(shí)間復(fù)雜度就變成了 O(m*n)

6，立方階O(n3)及K 次方階O(n^k)

　　參考上面O(n2)去理解就好了，相當(dāng)于三層n循環(huán)，其他的類似。

　　除此之外，其實(shí)還有 平均時(shí)間復(fù)雜度、均攤時(shí)間復(fù)雜度、最壞時(shí)間復(fù)雜度、最好時(shí)間復(fù)雜度 的分析方法，有點(diǎn)復(fù)雜，這里就不展開了。

1.2 空間復(fù)雜度

　　空間復(fù)雜度：用來(lái)評(píng)估算法內(nèi)存占用大小的式子。

　　既然時(shí)間復(fù)雜度不是用來(lái)計(jì)算程序具體耗時(shí)的，那么我們也應(yīng)該明白，空間復(fù)雜度也不是用來(lái)計(jì)算程序?qū)嶋H占用的空間的。空間復(fù)雜度是對(duì)一個(gè)算法在運(yùn)行過(guò)程中臨時(shí)占用存儲(chǔ)空間大小的一個(gè)量度，同樣反映的是一個(gè)趨勢(shì)，我們用S(N)來(lái)定義。

　　空間復(fù)雜度的表示方式與時(shí)間復(fù)雜度完全一樣：

算法使用了幾個(gè)變量：O(1)

算法使用了長(zhǎng)度為 n 的一維列表： O(n)

算法使用了m 行 n 列的二維列表：O(mn)

　　空間復(fù)雜度比較常用的有：O(1)，O(n)，O(n2)，我們來(lái)看看：

空間復(fù)雜度O(1)

　　如果算法執(zhí)行所需要的臨時(shí)空間不隨著某個(gè)變量n的大小而變化，即此算法空間復(fù)雜度為一個(gè)常量，可以表示為O(1)。

　　舉例：

int?i = 1;int?j = 2;++i;j++;int?m = i + j;

　　代碼中的i，j，m所分配的空間都不隨著處理數(shù)據(jù)量變化，因此他的空間復(fù)雜度S(n) = O(1)

空間復(fù)雜度O(n)

　　我們先看一個(gè)代碼：

int[] m =?new?int[n]for(i=1; i<=n; ++i){???j = i;???j++;}　　

這段代碼中，第一行new了一個(gè)數(shù)組出來(lái)，這個(gè)數(shù)據(jù)占用的大小為n，這段代碼的2~6行，雖然有循環(huán)，但是沒(méi)有再分配新的空間，因此，這段代碼的空間復(fù)雜度主要看第一行即可，即S(n)=O(n)。

空間換時(shí)間：常會(huì)為了追求時(shí)間復(fù)雜度而犧牲空間復(fù)雜度。

1.3 如何簡(jiǎn)單快速的判斷算法復(fù)雜度

快速判斷算法復(fù)雜度(適用于絕大多數(shù)簡(jiǎn)單情況)：

確定問(wèn)題規(guī)模 n

循環(huán)減半過(guò)程 ——> logN

k層關(guān)于 n 的循環(huán)——> nk

復(fù)雜情況：根據(jù)算法執(zhí)行過(guò)程判斷

2，常用的算法總結(jié)

2.1 遞歸

2.1.1 遞歸概念

　　遞歸的兩個(gè)特點(diǎn)：1:，調(diào)用自身 2，結(jié)束條件

　　舉個(gè)例子學(xué)習(xí)下面函數(shù)是不是遞歸：

# 這個(gè)是一個(gè)死遞歸，只調(diào)用自身，但是沒(méi)有結(jié)束條件def func1(x):????print(x)????func1(x-1)?# 這個(gè)是一個(gè)死遞歸，看似有結(jié)束條件，但是卻無(wú)法結(jié)束def func2(x):????if?x > 0:????????print(x)????????func2(x+1)?# 這是一個(gè)遞歸函數(shù),滿足調(diào)用自身，并且有結(jié)束條件def func3(x):????if?x > 0:????????print(x)????????func3(x-1)??# 這個(gè)也是一個(gè)遞歸，但是和func3有區(qū)別def func4(x):????if?x > 0:????????func4(x-1)????????print(x)

　　func3和func4的區(qū)別是什么？

　　假設(shè)x為3，那么func3輸出的結(jié)果為：3,2,1 而 func4輸出的結(jié)果為： 1,2,3。

　　為了方便理解，我們利用如下圖：

2.1.2 遞歸實(shí)例：漢諾塔問(wèn)題

　　問(wèn)題描述：大梵天創(chuàng)造世界的時(shí)候做了三根金剛石柱子，在一根柱子上從上往下按照大小順序摞著64片黃金圓盤。大梵天命名婆羅門把圓盤從下面開始按大小順序重新擺放在另一個(gè)柱子上。在小圓盤上不能放大圓盤，在三根柱子之間只能移動(dòng)一個(gè)圓盤。64根柱子移動(dòng)完畢之日，就是世界毀滅之時(shí)。

　　問(wèn)題分析：

　　代碼實(shí)現(xiàn)：

def hanoi(x,a,b,c):????if?x>0:????????# 除了下面最大的盤子，剩下的盤子從a移動(dòng)到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')??# 計(jì)算次數(shù)def cal_times(x):????num = 1????for?i?in?range(x-1):????????# print(i)????????num = 2*num +1????print(num)??cal_times(3)

　　遞歸總結(jié)：

• 1，漢諾塔移動(dòng)次數(shù)的遞推式： h(x) = 2h(x-1)+1
• 2，h(64) = 18446744073709551615
• 3，假設(shè)婆羅門每秒鐘搬一個(gè)盤子，則總共需要 5800億年

　證明：為什么漢諾塔的計(jì)算次數(shù)是2n+1呢？

　　對(duì)于一個(gè)單獨(dú)的塔，可以進(jìn)行以下操作：

• 1：將最下方的塔的上方的所有塔移動(dòng)到過(guò)渡柱子
• 2：將底塔移動(dòng)到目標(biāo)柱子
• 3：將過(guò)渡柱子上的其他塔移動(dòng)到目標(biāo)柱子

所以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再進(jìn)一步，可以得到通項(xiàng)公式為　　f(x)=2^x-1

2.2 查找算法

　　查找：在一些數(shù)據(jù)元素中，通過(guò)一定的方法找出與給定關(guān)鍵字相同的數(shù)據(jù)元素的過(guò)程。

　　列表查找(線性表查找)：從列表中查找指定元素

輸入：列表，待查找元素

輸出：元素下標(biāo)(未找到元素時(shí)一般返回None或 -1)

內(nèi)置列表查找函數(shù)：index()

2.2.1 順序查找(Linear Search)

　　順序查找：也叫線性查找，從列表第一個(gè)元素開始，順序進(jìn)行搜索，直到找到元素或搜索到列表最后一個(gè)元素為止。

　　時(shí)間復(fù)雜度為：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)

　　二分查找：又叫折半查找，從有序列表的初始候選區(qū) li[0:n] 開始，通過(guò)對(duì)待查找的值與候選區(qū)中間值得比較，可以使候選區(qū)減少一半。

　　時(shí)間復(fù)雜度：O(logN)

def binary_search(data_list, val):???????low = 0???????????????????????? # 最小數(shù)下標(biāo)???????high = len(data_list) - 1?????? # 最大數(shù)下標(biāo)???????while?low <= high:???????????????mid = (low + high)?// 2???? # 中間數(shù)下標(biāo)???????????????if?data_list[mid] == val:?? # 如果中間數(shù)下標(biāo)等于val, 返回???????????????????????return?mid???????????????elif data_list[mid] > val:? # 如果val在中間數(shù)左邊, 移動(dòng)high下標(biāo)???????????????????????high = mid - 1???????????????else:?????????????????????? # 如果val在中間數(shù)右邊, 移動(dòng)low下標(biāo)???????????????????????low = mid + 1????else:???????????return?None??? # val不存在, 返回None?ret = binary_search(list(range(1, 10)), 3)print(ret)

2.3 列表排序算法

　　排序：將一組“無(wú)序”的記錄序列調(diào)整為“有序” 的記錄序列。

　　列表排序：將無(wú)序列表變?yōu)橛行蛄斜?/p>

• 輸入：列表
• 輸出：有序列表

　　升序與降序

　　內(nèi)置排序算法：sort()

2.3.1 常見排序算法

　　如下圖所示：

　　部分排序算法的時(shí)間復(fù)雜度和空間復(fù)雜度及其穩(wěn)定性如下：

2.3.2 冒泡排序(Bubble Sort)

　　冒泡排序：像開水燒氣泡一樣，把最大的元素冒泡到最上面。一趟就是把最大的冒到最上面。冒到最上面的區(qū)域叫有序區(qū)。下面叫無(wú)序區(qū)。

　　列表每?jī)蓚€(gè)相鄰的數(shù)，如果前面比后面大，則交換這兩個(gè)數(shù)。

　　一趟排序完成后，則無(wú)序區(qū)減少一個(gè)數(shù)，有序區(qū)增加一個(gè)數(shù)。

　　代碼關(guān)鍵點(diǎn)：趟，無(wú)序區(qū)范圍

　　時(shí)間復(fù)雜度：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]'''

　 當(dāng)然也可以打印每一趟，看看冒泡排序的過(guò)程：

# 升序排列，打印每一趟，看看其過(guò)程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]'''

　　冒泡排序的最差情況，即每次都交互順序的情況下，時(shí)間復(fù)雜度為O(n**2)。

　　存在一個(gè)最好情況就是列表本來(lái)就是排好序，所以可以加一個(gè)優(yōu)化，也就是一個(gè)標(biāo)志位，如果沒(méi)有出現(xiàn)交換的情況，說(shuō)明列表已經(jīng)有序，可以直接結(jié)束算法，則直接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)

　　一趟排序記錄最小的數(shù)，放到第一個(gè)位置

　　再一趟排序記錄記錄列表無(wú)序區(qū)最小的數(shù)，放到第二個(gè)位置。。。。

　　算法的關(guān)鍵點(diǎn)：有序區(qū)和無(wú)序區(qū)，無(wú)序區(qū)最小數(shù)的位置。

　　先看一個(gè)簡(jiǎn)單的選擇排序

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_newli = [4,3,2,1]print(select_sort_simple(li))# [1, 2, 3, 4]

　　我們會(huì)發(fā)現(xiàn)首先他生成了兩個(gè)列表，那么就占用了兩份內(nèi)存，而算法的思想則是能省則省，能摳則摳，所以我們需要改進(jìn)一下。

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)

　　原理：把列表分成有序區(qū)和無(wú)序區(qū)兩個(gè)部分。最初有序區(qū)只有一個(gè)元素。然后每次從無(wú)序區(qū)選擇一個(gè)元素，插入到有序區(qū)的位置，直到無(wú)序區(qū)變空。

def insert_sort(li):????for?i?in?range(1, len(li)):? # i表示摸到的牌的下標(biāo)????????temp = li[i]????????j = i - 1? # j指的時(shí)手里的牌的下標(biāo)????????# if j > 0 and temp < li[j]:? # 找到一個(gè)合適地位置插進(jìn)去????????while?j >= 0 and li[j] > temp:????????????li[j + 1] = li[j]????????????j -= 1????????li[j + 1] = temp????return?li

　　簡(jiǎn)單形象的一張圖：

　　時(shí)間復(fù)雜度是 O(n2)

　　如果目標(biāo)是 n 個(gè)元素的序列升序排列，那么采用插入排序存在最好情況和最壞的情況。最好情況就是，序列已經(jīng)是升序排列了，在這種情況下，需要進(jìn)行的比較操作需要(n-1)次即可。最壞的情況就是序列是降序排列，那么此時(shí)需要進(jìn)行的比較共有 n(n-1)/2次。插入排序的賦值操作時(shí)比較操作的次數(shù)加上 (n-1)次。平均來(lái)說(shuō)插入排序算法的時(shí)間復(fù)雜度為O(n^2)，因而插入排序不適合對(duì)于數(shù)據(jù)量比較大的排序應(yīng)用。但是，如果需要排序的數(shù)據(jù)量很小，例如量級(jí)小于千，那么插入排序還是一個(gè)不錯(cuò)的選擇。

2.3.5 快速排序

　　原理：讓指定的元素歸位，所謂歸位，就是放到他應(yīng)該放的位置(左邊的元素比他小，右邊的元素比他大)，然后對(duì)每個(gè)元素歸位，就完成了排序。

　　可以參考下面動(dòng)圖來(lái)理解代碼：

　　左邊空位置，從右邊找，右邊空位置，從左邊找。當(dāng)左邊和右邊重合的時(shí)候，就是mid。

　　　　下圖來(lái)自百度百科

　　快速排序——框架函數(shù)

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):????# 把左邊第一個(gè)元素賦值給tmp，此時(shí)left指向空????tmp = data[left]????# 如果左右兩個(gè)指針不重合，則繼續(xù)????while?left < right:????????while?left < right and data[right] >= tmp:????????????right -= 1?? # 右邊的指標(biāo)往左走一步????????# 如果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??# 寫好歸位函數(shù)后，就可以遞歸調(diào)用這個(gè)函數(shù)，實(shí)現(xiàn)排序def quick_sort(data, left, right):????if?left < right:????????# 找到指定元素的位置????????mid = partition(data, left, right)????????# 對(duì)左邊的元素排序????????quick_sort(data, left, mid - 1)????????# 對(duì)右邊的元素排序????????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]'''

　　正常的情況，快排的復(fù)雜度是O(nlogn)

　　快排存在一個(gè)最壞情況，就是每次歸位，都不能把列表分成兩部分，此時(shí)復(fù)雜度就是O(n2)了，如果要避免設(shè)計(jì)成這種最壞情況，可以在取第一個(gè)數(shù)的時(shí)候不要取第一個(gè)了，而是取一個(gè)列表中的隨機(jī)數(shù)。

2.3.6 堆排序(Heap Sort)

　　本質(zhì)是使用大根堆或小根堆來(lái)對(duì)一個(gè)數(shù)組進(jìn)行排序。所以首先要理解樹的概念。

　　關(guān)于樹的理解請(qǐng)參考博客：https://www.cnblogs.com/wj-1314/p/11631934.html

　　堆簡(jiǎn)單來(lái)說(shuō)：一種特殊的完全二叉樹結(jié)構(gòu)

• 大根堆：一種完全二叉樹，滿足任一節(jié)點(diǎn)都比其孩子節(jié)點(diǎn)大
• 小根堆：一種完全二叉樹，滿足任一節(jié)點(diǎn)都比其孩子節(jié)點(diǎn)小

堆排序——堆的向下調(diào)整性質(zhì)

　　假設(shè)根節(jié)點(diǎn)的左右子樹都是堆，但根節(jié)點(diǎn)不滿足堆的性質(zhì)，可以通過(guò)一次向下的調(diào)整來(lái)將其變成一個(gè)堆

　　當(dāng)根節(jié)點(diǎn)的左右子樹都是堆時(shí)，可以通過(guò)一次向下的調(diào)整來(lái)將其變換成一個(gè)堆。

堆排序過(guò)程

1，建立堆

2，得到堆頂元素，為最大元素

3，去掉堆頂，將堆最后一個(gè)元素放到堆頂，此時(shí)可以通過(guò)一次調(diào)整重新使堆有序。

4，堆頂元素為第二大元素

5，重復(fù)步驟3，直到堆變?yōu)榭?/p>

　　代碼如下：

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表示建堆的時(shí)候調(diào)整的部分的跟的下標(biāo)????????sift(li, i, n - 1)????# 建堆完成了????print('建堆完成后的列表：',li)????for?i?in?range(n-1, -1, -1):????????# i 指向當(dāng)前堆的最后一個(gè)元素????????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 randomrandom.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]'''

堆排序應(yīng)用——topK問(wèn)題

　　問(wèn)題描述：現(xiàn)在有n個(gè)數(shù)，設(shè)計(jì)算法得到前k大的數(shù)( k

　　解決思路：

排序后切片 時(shí)間復(fù)雜度為：O(nlogn)

排序(選擇，插入，冒泡) 時(shí)間復(fù)雜度為：O(mn)

堆排序思路 時(shí)間復(fù)雜度為：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，出數(shù)????return?heap??import random?li = list(range(1000))random.shuffle(li)print(topk(li, 10))

2.3.7 歸并排序(Merge Sort)

　　歸并：假設(shè)現(xiàn)在的列表分兩段有序，如何將其合成為一個(gè)有序列表，這種操作叫做一次歸并。

　　如下圖所示：虛線分開，兩個(gè)箭頭分別指向列表的第一個(gè)元素。然后從左邊開始比較兩邊的元素，小的出列。然后繼續(xù)循環(huán)，這樣就排出來(lái)一個(gè)有序列表。

　　應(yīng)用到排序就是把列表分成一個(gè)元素一個(gè)元素的，一個(gè)元素當(dāng)然是有序的，將有序列表一個(gè)一個(gè)合并，列表越來(lái)越大，最終合并成一個(gè)有序的列表。

　　歸并排序如圖所示：

　　歸并排序代碼如下：

def merge(li, low, mid, high):????i = low? # i為左邊列表開頭元素的坐標(biāo)????j = mid + 1? # j為右邊列表開頭元素的坐標(biāo)????ltmpd = []? # 臨時(shí)列表????# 只要兩邊都有數(shù)????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執(zhí)行完，肯定有一部分沒(méi)數(shù)字了，就是兩個(gè)箭頭肯定有一個(gè)指向沒(méi)數(shù)了????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:? # 列表中至少兩個(gè)元素，遞歸????????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 randomrandom.shuffle(li)print(li)merge_sort(li, 0, len(li)-1)print(li)

　　歸并排序的時(shí)間復(fù)雜度：O(nlogn)

　　歸并排序的空間復(fù)雜度：O(n)

2.3.8 快速排序，堆排序，歸并排序三種算法的總結(jié)

1，三種排序算法的時(shí)間復(fù)雜度都是O(nlogn)

2，一般情況下，就運(yùn)行時(shí)間而言：快速排序 < 歸并排序 < 堆排序

3，三種排序算法的缺點(diǎn)

• 快速排序：極端情況下排序效率低
• 歸并排序：需要額外的內(nèi)存開銷
• 堆排序：在快的排序算法中相對(duì)較慢

2.3.9 希爾排序(Shell Sort)

　　希爾排序(Shell Sort)是一種分組插入排序算法。

　　其算法步驟如下：

• 首先取一個(gè)整數(shù) d1=n/2，將元素分為 d1個(gè)組，每組相鄰量元素之間距離為 d1，在各組內(nèi)進(jìn)行直接插入排序；
• 然后取第二個(gè)整數(shù) d2=d1/2，重復(fù)上述分組排序過(guò)程，知道 di=1，即所有元素在同一組內(nèi)進(jìn)行直接插入排序；
• 最后希爾排序每趟并不使某些元素有序，而是使整體數(shù)據(jù)越來(lái)越接近有序，最后一趟排序使得所有數(shù)據(jù)有序

　　圖解如下：

　　1，數(shù)組(列表)如下：

　　 2，d=4(即d=len(li)/2):

　　3，d=2：

　　 4，d=1：

　　在wiki查找地址如下：https://en.wikipedia.org/wiki/Shellsort#Gap_sequences

　　希爾排序的時(shí)間復(fù)雜度討論比較復(fù)雜，并且和選取的gap序列有關(guān)。

2.3.10 計(jì)數(shù)排序(Count Sort)

　　簡(jiǎn)單來(lái)說(shuō)如下圖所示：

　　出現(xiàn)那個(gè)數(shù)，就給那個(gè)數(shù)的數(shù)量加一。

　　代碼如下：

def count_sort(li, max_count=100):????count = [0?for?_?in?range(max_count+1)]????for?val?in?li:????????count[val] += 1????li.clear()? # 原列表清空，這樣就不用建新列表，省內(nèi)存????for?ind, val?in?enumerate(count):????????for?i?in?range(val):????????????li.append(ind)?import randomli = [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]'''

　　對(duì)列表進(jìn)行排序，已知列表中的數(shù)范圍都在0到100之間，設(shè)計(jì)時(shí)間復(fù)雜度為O(n)的算法。就可以使用此算法，即使列表長(zhǎng)度大約為100萬(wàn)，雖然列表長(zhǎng)度很大，但是數(shù)據(jù)量很小，會(huì)有大量的重復(fù)數(shù)據(jù)，我們可以考慮對(duì)這100個(gè)數(shù)進(jìn)行排序。

2.3.11 桶排序(Bucket Sort)

　　桶排序也叫計(jì)數(shù)排序，簡(jiǎn)單來(lái)說(shuō)，就是將數(shù)據(jù)集里面所有元素按順序列舉出來(lái)，然后統(tǒng)計(jì)元素出現(xiàn)的次數(shù)，最后按照順序輸出數(shù)據(jù)集里面的元素。

　　在計(jì)數(shù)排序中，如果元素的范圍比較大(比如在1到1億之間)，如何改造算法？

　　桶排序(Bucket Sort)：首先將元素分在不同的桶中，在對(duì)每個(gè)桶中的元素排序。

　　如上圖，列表為 [29, 25, 3, 49, 9, 37, 21, 43]排序，我們知道數(shù)組的范圍是0~49，我們將其分為5個(gè)桶，然后放入數(shù)字，一次對(duì)桶中的元素排序。

　　桶排序的表現(xiàn)取決于數(shù)據(jù)的分布。也就是需要對(duì)不同數(shù)據(jù)排序采取不同的分桶策略。

• 平均情況時(shí)間復(fù)雜度為：O(n+k)
• 最壞情況時(shí)間復(fù)雜度為：O(n2k)
• 空間復(fù)雜度為：O(nk)

　　代碼如下：

#_*_coding:utf-8_*_?def bucket_sort(li, n=100, max_num=10000):????buckets = [[]?for?_?in?range(n)]? # 創(chuàng)建桶????for?var?in?li:????????# 0 -》 0， 86????????i = min(var?// (max_num // n), n-1)? # i表示var放到幾號(hào)桶里????????buckets[i].append(var)? # 把var加入到桶里????????# [0, 2, 4]????????# 保持桶內(nèi)的順序????????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 randomif?__name__ ==?'__main__':????li = [random.randint(0, 10000)?for?i?in?range(10000)]????# print(li)????li = bucket_sort(li)????print(li)

2.3.12 基數(shù)排序

　　多關(guān)鍵字排序：加入現(xiàn)在有一個(gè)員工表，要求按照薪資排序，年齡相同的員工按照年齡排序。

　　方法：先按照年齡進(jìn)行排序，再按照薪資進(jìn)行穩(wěn)定的排序。

　　比如對(duì) [32, 13, 94, 52, 17, 54, 93] 排序是否可以看成多關(guān)鍵字排序？

　　實(shí)現(xiàn)示例如下：

　　1，首先按照個(gè)位分桶：

　　2，按照個(gè)位數(shù)分好,桶，然后擺回原位

　　3，按照十位數(shù)進(jìn)行分桶，然后將桶里的數(shù)排序

　　基數(shù)排序是一種非比較型整數(shù)排序算法，其原理是將整數(shù)按位數(shù)切割成不同的數(shù)字，然后按照每個(gè)位數(shù)分別比較。由于整數(shù)也可以表達(dá)字符串(比如名稱或日期)和特定格式的浮點(diǎn)數(shù)，所以基礎(chǔ)排序也不是只能使用于整數(shù)。

　　基數(shù)排序的時(shí)間復(fù)雜度為：O(kn)

　 基數(shù)排序的空間復(fù)雜度為：O(k+n)

　　基數(shù)排序中 k 表示數(shù)字位數(shù)

　　 　　由于基數(shù)排序使用了桶排序，所以空間復(fù)雜度和桶排序的空間復(fù)雜度是一樣的。

　　代碼如下：

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 基數(shù)排序 VS 計(jì)數(shù)排序 VS 桶排序

　　這三種排序算法都利用了桶的概念，但對(duì)于桶的使用方法上有明顯差異。

• 基數(shù)排序：根據(jù)鍵值的每位數(shù)字來(lái)分配桶
• 計(jì)數(shù)排序：每個(gè)桶只存儲(chǔ)單一鍵值
• 桶排序：每個(gè)桶存儲(chǔ)一定范圍內(nèi)的數(shù)值

三，幾道查找排序習(xí)題

　　這一節(jié)是對(duì)前面學(xué)習(xí)的算法的應(yīng)用，也就是習(xí)題練習(xí)。

1，給兩個(gè)字符串s和t，判斷 t是否為s的重新排列后組成的單詞

　　s = 'anagram' t='nagaram' return true

　　s='rat', t='car', return false

　　兩種方法一種直接使用Python的list排序，當(dāng)然這種時(shí)間復(fù)雜度可能高一些。另一種方法使用字典記錄list中出現(xiàn)字母的次數(shù)。代碼如下：

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，給定一個(gè) m*n 的二維列表，查找一個(gè)數(shù)是否存在，列表有下列特性：

• 每一行的列表從左到右已經(jīng)排序好
• 每一行第一個(gè)數(shù)比上一行最后一個(gè)數(shù)大

　　思路如下：有兩個(gè)方法，第一個(gè)是暴力遍歷法，但是這種時(shí)間復(fù)雜度會(huì)很高，而相對(duì)來(lái)說(shuō)改進(jìn)的方法是二分查找。

　　實(shí)現(xià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 即為 []????# 當(dāng)然也出現(xiàn)一種可能就是 [[],[]]????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 = 32res = searchMatrix1(matrix, target)print(res)

3，給定一個(gè)列表和一個(gè)整數(shù)，設(shè)計(jì)算法找到兩個(gè)數(shù)的下標(biāo)，使得兩個(gè)數(shù)之和為給定的整數(shù)。保證肯定僅有一個(gè)結(jié)果。例如，列表[1,2,5,4] 與目標(biāo)整數(shù)3,1+2=3，結(jié)果為(0,1)

　　代碼如下：

def TwoSum(nums, target):????'''?????:param nums:? nums是代表一個(gè)list????:param target: target是一個(gè)數(shù)????:return: 結(jié)果返回的時(shí)兩個(gè)數(shù)的下標(biāo)????'''????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):????# 新建一個(gè)空字典用來(lái)保存數(shù)值及在其列表中對(duì)應(yīng)的索引????dict1 = {}????for?i?in?range(len(nums)):????????# 相減得到另一個(gè)數(shù)值????????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: # 候選區(qū)有值????????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)

總結(jié)

以上是生活随笔為你收集整理的python常用代码_Python常用算法学习(3)（原理+代码）——最全总结的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。