1、什么是算法？

算法（Algorithm）：一個計算過程，解決問題的方法

2、復習：遞歸

遞歸的兩個特點：（1） 調用自身 （2）結束條件

deffunc1(x):print(x)

func1(x-1)deffunc2(x):if x>0:print(x)

func2(x+1)deffunc3(x):if x>0:print(x)

func3(x-1)deffunc4(x):if x>0:

func4(x-1)print(x)

View Code

func1和func2不是遞歸

func3和func4是遞歸，但是結果不一樣，func3（5）打印的是5,4,3,2，1 而func4（5）結果是1,2,3,4,5

3、時間復雜度

時間復雜度：用來評估算法運行效率的一個東西

小結：

時間復雜度是用來估計算法運行時間的一個式子（單位）。

一般來說，時間復雜度高的算法比復雜度低的算法快。

常見的時間復雜度（按效率排序）

O(1)

不常見的時間復雜度（看看就好）

O(n!) O(2n) O(nn) …

如何一眼判斷時間復雜度？

循環減半的過程?O(logn)

幾次循環就是n的幾次方的復雜度

4、空間復雜度

空間復雜度：用來評估算法內存占用大小的一個式子

5、列表查找

列表查找：從列表中查找指定元素

輸入：列表、待查找元素

輸出：元素下標或未查找到元素

6、順序查找

從列表第一個元素開始，順序進行搜索，直到找到為止。

7、二分查找

從有序列表的候選區data[0:n]開始，通過對待查找的值與候選區中間值的比較，可以使候選區減少一半。

defbin_search(data_set,val):'''mid：下標

low：每次循環的列表最左邊下標

high：每次循環的列表最右邊下標

:param data_set:列表

:param val: 要找的值

:return:'''low=0

high= len(data_set)-1

while low <=high:

mid= (low+high)//2

if data_set[mid] ==val:returnmidelif data_set[mid] >val:

high= mid - 1

else:

low= mid + 1

return

View Code

8、列表排序

將無序列表變為有序列表

應用場景： 各種榜單 各種表格 給二分查找用 給其他算法用

輸入：無序列表

輸出：有序列表

9、排序中比較慢的三種： 冒泡排序 選擇排序 插入排序

快速排序

排序NB二人組： 堆排序 歸并排序

沒什么人用的排序： 基數排序 希爾排序 桶排序

算法關鍵點： 有序區 無序區

10、冒泡排序

首先，列表每兩個相鄰的數，如果前邊的比后邊的大，那么交換這兩個數

n = len(list),循環了i趟（i=n-1），第i趟循環比較了(j = n-i-1 )次，j是每趟循環比較的次數

importrandom,time#裝飾器

defcal_time(func):def wrapper(*args,**kwargs):

t1=time.time()

ret= func(*args,**kwargs)

t2=time.time()print('time cost: %s \r\nfunc from %s'%(t2-t1,func.__name__))returnfuncreturnwrapper

@cal_timedefbubble_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]#降續

#if li[j] < li[j+1]:

#li[j],li[j+1]=li[j+1],li[j]

data= list(range(1000))

random.shuffle(data)print(data)

bubble_sort(data)print(data)

View Code

優化后的冒泡排序：

如果冒泡排序中執行一趟而沒有交換，則列表已經是有序狀態，可以直接結束算法。

importrandom,time#裝飾器

defcal_time(func):def wrapper(*args,**kwargs):

t1=time.time()

ret= func(*args,**kwargs)

t2=time.time()print('time cost: %s \r\nfunc from %s'%(t2-t1,func.__name__))returnfuncreturnwrapper

@cal_timedefbubble_sort(li):for i in range(len(li) - 1):

exchange=Falsefor j in range(len(li) - i - 1):#升續

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

li[j],li[j+1]=li[j+1],li[j]

exchange=True#降續

#if li[j] < li[j+1]:

#li[j],li[j+1]=li[j+1],li[j]

#exchange = True

#這里是指上一趟，值之間沒有發生交換，就退出循環

if notexchange:breakdata= list(range(1000))

random.shuffle(data)print(data)

bubble_sort(data)print(data)

View Code

11、選擇排序

一趟遍歷記錄最小的數，放到第一個位置； 再一趟遍歷記錄剩余列表中最小的數，繼續放置；

importrandom,time#裝飾器

defcal_time(func):def wrapper(*args,**kwargs):

t1=time.time()

ret= func(*args,**kwargs)

t2=time.time()print('time cost: %s --> \nfunc from %s'%(t2-t1,func.__name__))returnfuncreturnwrapper

@cal_timedefselect_sort(li):for i in range(len(li)-1):

min_loc=ifor j in range(i+1,len(li)):if li[j]

min_loc=j

li[i],li[min_loc]= li[min_loc],li[i]

View Code

12、插入排序

definsert_sort(li):for i in range(1,len(li)):

tmp=li[i]

j= i - 1

while j >= 0 and tmp

li[j+ 1] =li[j]

j-= 1li[j+ 1] = tmp

View Code

13、練習 用冒泡法把打亂的帶ID的信息表排序

importrandomdefrandom_list(n):

ids= range(1000,1000+n)

result=[]

a1= ["王","陳","李","趙","錢","孫","武"]

a2= ["丹","澤","","","晶","杰","金"]

a3= ["強","華","國","富","宇","齊","星"]for i inrange(n):

age= random.randint(16,38)

id=ids[i]

name= '%s%s%s'%(random.choice(a1),random.choice(a2),random.choice(a3))

dic={}

dic['id'] =id

dic['姓名'] =name

dic['年齡'] =age

result.append(dic)returnresultdefbubble_sort(li):for i in range(len(li)-1):for j in range(len(li)-i-1):if li[j]['id'] > li[j+1]['id']:

li[j],li[j+1] = li[j+1],li[j]

data1= random_list(100)

random.shuffle(data1)print(data1)

bubble_sort(data1)print(data1)

View Code

14、快速排序：快

好寫的排序算法里最快的

快的排序算法里最好寫的

快排思路：

取一個元素p（第一個元素），使元素p歸位；

列表被p分成兩部分，左邊都比p小，右邊都比p大；

遞歸完成排序。

#快排的復雜度是O（nlog（n）），這是一個特殊情況

#口訣 右手左手一個慢動作，右手左手慢動作重播（遞歸）

importtime,random,copydefcal_time(func):def wrapper(*args,**kwargs):

t1=time.time()

ret= func(*args,**kwargs)

t2=time.time()print('time cost： %s from %s'%(t2-t1,func.__name__))returnfuncreturnwrapperdefquick_sort_x(data,left,right):#這里的left和right是定義列表data，最少有兩個元素

if left

mid =partition(data,left,right)#以下類似二分

quick_sort_x(data,left,mid-1)

quick_sort_x(data,mid+1,right)#快排的復雜度是O（nlog（n）），這是一個特殊情況

defpartition(data,left,right):#獲取左邊的第一個元素，這里寫left不能寫零，因為后面需要遞歸

tmp =data[left]#終止條件為當left和right碰上時，所以左小于右時為while循環的條件（left和right是下標）

while left

while left < right and data[right] >=tmp:

right-= 1

#把找到的右邊比tmp小的數移到左邊空出來的位置

data[left] =data[right]#循環條件是左邊比tmp小，繼續循環，直到找到左邊比tmp大的數，結束循環

while left < right and data[left] <=tmp:

left+= 1

#把左邊找到的大于tmp的數移到右邊空出來的位置

data[right] =data[left]#當左右相等時,就把tmp放到left和right碰到的位置

data[left] =tmp#mid的值和lef或right值相同，return哪個都可以

#mid = left

#return mid

returnleft#對遞歸函數的裝飾，需要再封裝一層

@cal_timedefquik_sort(data):#0及是left，len(data)-1為right

return quick_sort_x(data,0,len(data)-1)

View Code

importtime,random,copydefcal_time(func):def wrapper(*args,**kwargs):

t1=time.time()

ret= func(*args,**kwargs)

t2=time.time()print('time cost： %s from %s'%(t2-t1,func.__name__))returnfuncreturnwrapperdefquick_sort_x(data,left,right):#這里的left和right是定義列表data，最少有兩個元素

if left

mid =partition(data,left,right)#以下類似二分

quick_sort_x(data,left,mid-1)

quick_sort_x(data,mid+1,right)#快排的復雜度是O（nlog（n）），這是一個特殊情況

defpartition(data,left,right):#獲取左邊的第一個元素，這里寫left不能寫零，因為后面需要遞歸

tmp =data[left]#終止條件為當left和right碰上時，所以左小于右時為while循環的條件（left和right是下標）

while left

while left < right and data[right] >=tmp:

right-= 1

#把找到的右邊比tmp小的數移到左邊空出來的位置

data[left] =data[right]#循環條件是左邊比tmp小，繼續循環，直到找到左邊比tmp大的數，結束循環

while left < right and data[left] <=tmp:

left+= 1

#把左邊找到的大于tmp的數移到右邊空出來的位置

data[right] =data[left]#當左右相等時,就把tmp放到left和right碰到的位置

data[left] =tmp#mid的值和lef或right值相同，return哪個都可以

#mid = left

#return mid

returnleft#對遞歸函數的裝飾，需要再封裝一層

@cal_timedefquik_sort(data):#0及是left，len(data)-1為right

return quick_sort_x(data,0,len(data)-1)#冒泡排序

@cal_timedefbubble_sort(li):for i in range(len(li) - 1):

exchange=Falsefor j in range(len(li) - i - 1):#升續

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

li[j],li[j+1]=li[j+1],li[j]

exchange=True#降續

#if li[j] < li[j+1]:

#li[j],li[j+1]=li[j+1],li[j]

#exchange = True

#這里是指上一趟，值之間沒有發生交換，就退出循環

if notexchange:breakdata= list(range(5000))

random.shuffle(data)#深度拷貝

data1 =copy.deepcopy(data)

data2=copy.deepcopy(data)#快排和冒泡的比較

quik_sort(data1)

bubble_sort(data2)print(data1)

View Code

升續：

降續：

排序速度的定義：

一般情況下快排比冒泡快，快排有遞歸深度的問題，如果深度高的話，需要調整。

15、堆排序

（1）樹與二叉樹簡介

樹是一種數據結構 比如：目錄結構

樹是一種可以遞歸定義的數據結構

樹是由n個節點組成的集合：

如果n=0，那這是一棵空樹；

如果n>0，那存在1個節點作為樹的根節點，其他節點可以分為m個集合，每個集合本身又是一棵樹。

一些概念

根節點、葉子節點

樹的深度（高度）

樹的度

孩子節點/父節點 子樹

（2）二叉樹

二叉樹：度不超過2的樹（節點最多有兩個叉）

（3）滿二叉樹，完全二叉樹

（4）二叉樹的存儲方式

鏈式存儲方式

順序存儲方式（列表）

父節點和左孩子節點的編號下標有什么關系？

0-1 1-3 2-5 3-7 4-9

i ~ 2i+1

父節點和右孩子節點的編號下標有什么關系？

0-2 1-4 2-6 3-8 4-10

i ~ 2i+2

（5）小結

二叉樹是度不超過2的樹

滿二叉樹與完全二叉樹

（完全）二叉樹可以用列表來存儲，通過規律可以從父親找到孩子或從孩子找到父親

（6）堆排序

大根堆：一棵完全二叉樹，滿足任一節點都比其孩子節點大

小根堆：一棵完全二叉樹，滿足任一節點都比其孩子節點小

（7）堆排序過程

a、建立堆

b、得到堆頂元素，為最大元素

c、去掉堆頂，將堆最后一個元素放到堆頂，此時可通過一次調整重新使堆有序。

d、堆頂元素為第二大元素。

e、 重復步驟3，直到堆變空。

總結

以上是生活随笔為你收集整理的python中什么是算法_python自动开发之（算法）第二十七天的全部內容，希望文章能夠幫你解決所遇到的問題。

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