1. 程式人生 > >python 第二百零八天 ----算法相關

python 第二百零八天 ----算法相關

個數 search not range clas war 中間 n-1 ice

查找方法 : 順序查找法 二分查找法

技術分享圖片
 1 import time,random
 2 
 3 #時間計算
 4 def cal_time(func):
 5     def wrapper(*args,**kwargs):
 6         time1=time.time()
 7         n=func(*args,**kwargs)
 8         time2=time.time()
 9         print(func.__name__,times:,time2-time1)
10         return n
11     return
wrapper 12 13 #順序查找法 14 @cal_time 15 def linear_search(data_set,val): 16 for i in range(range(data_set)): 17 if data_set[i]==val: 18 return i 19 return 20 21 22 #二分查找法 23 @cal_time 24 def bin_search(data_set,val,*args,**kwargs):#二分查找 25 low=0 #最小下標 26 high=len(data_set)-1 #
最大下標 27 while low <= high: #當最小下標小於或等於最大下標時 進行調用 28 mid =(low+high)//2 # 二分計算 29 if data_set[mid]==val: #如果中間值等於要查找的值, 30 return mid #返回中間下標 31 elif data_set[mid]>val: #如果大於中間值 32 high=mid-1 #最大下標移到中間值之前一個位置 33 else: 34 low=mid+1 #
最小下標移到中間值之後一個位置 35 return 36 37 #@cal_time 38 def bin_search_dic(data_set,val):#二分查找 字典 39 low=0 #最小下標 40 high=len(data_set)-1 #最大下標 41 while low <= high: #當最小下標小於或等於最大下標時 進行調用 42 mid =(low+high)//2 # 二分計算 43 if data_set[mid][id]==val: #如果中間值等於要查找的值, 44 return mid #返回中間下標 45 elif data_set[mid][id]>val: #如果大於中間值 46 high=mid-1 #最大下標移到中間值之前一個位置 47 else: 48 low=mid+1 #最小下標移到中間值之後一個位置 49 return 50 51 52 @cal_time 53 def bin_search_dic_two(data_set,val): 54 return bin_search(data_set,val) 55 #字典生成 56 @cal_time 57 def random_list(n): 58 result=[]#空列表 59 ids=list(range(1001,1001+n))#id的列表 60 a1=[Y,L,D,I,P] 61 a2=[t,s,‘‘,‘‘,e,o] 62 a3=[s,n,x,r] 63 for i in range(n): 64 temp={} 65 id=ids[i] #id有序 66 age = random.randint(18,60)#隨機生成 18到60之間 67 name=random.choice(a1)+random.choice(a2)+random.choice(a3) 68 temp={id:id,age:age,name:name} 69 result.append(temp) 70 return result 71 72 73 data=list(range(10000000)) 74 bin_search(data,500) 75 name_list=random_list(9) 76 #print(name_list) 77 dics=bin_search_dic(name_list,1004) 78 #print(name_list[dics])
View Code

排序的多種算法:

#冒泡排序

 1 @cal_time
 2 def bubble_sort(list):
 3     for i in range(len(list)-1): #下標
 4         for j in range(len(list)-i -1):#排序後,下一趟的下標
 5             if list[j]>list[j+1]: #大於 升序
 6                 list[j],list[j+1]=list[j+1],list[j]  #進行交換
 7 
 8 @cal_time
 9 def bubble_sort_p(list):#冒泡排序 優化
10     for i in range(len(list)-1): #下標
11         tag=False  #交換標誌
12         for j in range(len(list)-i -1):
13             if list[j]>list[j+1]: #大於 升序
14                 list[j],list[j+1]=list[j+1],list[j]  #進行交換
15                 tag=True
16         if not tag:#如果沒有產生交換
17             break #直接退出

#選擇排序

 1 def select_sort(li):#選擇排序
 2     for i in range(len(li)-1):#n-1趟
 3         tag=False  #交換標誌
 4         min_loc=i #默認第一個為最小值的下標
 5         for j in range(i+1,len(li)):
 6             if li[j]< li[min_loc]:#如果當前下標值小於第一個下標,
 7                 min_loc=j  #最小值的下標位置進行更新下標
 8                 tag=True
 9         if not tag:#如果沒有產生交換
10             break #直接退出
11         else:
12             li[i],li[min_loc]=li[min_loc],li[i] #進行對換

#插入排序

 1 def insert(li,i):
 2     tmp=li[i]#取出當前值
 3     j=i-1 #對比的值的下標 向左對比
 4     while j>=0 and li[j]> tmp:#對比的下標不為負 ,對比的值大於取出的值,
 5         li[j+1]=li[j] #進行對換
 6         j=j-1 #下標左移
 7     li[j+1]=tmp #對比值比較小的右邊 放入取出的值
 8 
 9 #插入排序
10 @cal_time
11 def insert_sort(li):
12     for i in range(1,len(li)):# 當前下標
13         insert(li,i)#單次排序

#快排
 1 #遞歸 歸位
 2 def partition(data,left,right):
 3     tmp =data[left]# 從左邊取數
 4     while left <right: #左右下標不相碰
 5         while left <right and data[right]>= tmp: #右邊的值 大於取出的值時
 6             right-=1 #右邊下標左移一位
 7         data[left]=data[right]#找到右邊小於取出值 ,移到左邊空位
 8         while left < right and data[left] <=tmp:#左邊的值 小於取出的值時
 9             left +=1 #左邊右移一位
10         data[right]=data[left]#找到左邊大於取出值 ,移到右邊空位
11     data[left]=tmp #當左右下標相遇 取出值 放入空位
12     return  left #返回左下標
13 
14 #快排
15 def quick_sort(data,left,right):
16     if left <right:
17         mid =partition(data,left,right)#進行遞歸調整
18         quick_sort(data,left,mid-1)
19         quick_sort(data,mid+1,right)
堆排
 1 #堆排 將堆調整
 2 def sift_q(data,low,high):
 3     i= low #根  下標
 4     j=2*i+1  #對應的 左子節點 下標
 5     tmp =data[i] #取根下標值
 6     while j<=high: #如果左節點下標小於等於最大下標
 7         if  j <high and data[j]<data[j+1]: #如果左下標小在最大下標,並且,左了節點的數值小於 右子節點的數值
 8             j+=1 #下標右移一位
 9         if tmp < data[j]:#如果根節點的值小於,左子節點
10             data[i]=data[j] # 左子節點值,移到根節點
11             i=j #根下標 下移到原來的左子節點
12             j=2*i+1#對應的 左子節點 下標
13         else:
14             break
15     data[i]=tmp  #最後空位,放入取出的值
16 
17 #堆排序 升序
18 @cal_time
19 def sift(data):
20     n=len(data)
21     for i in range(n//2-1,-1,-1): #最後的父節點, 步長, 最後
22         sift_q(data,i,n-1)#進行調整
23     for i in range(n-1,-1,-1):# i指向堆的最後下標
24         data[0],data[i] =data[i],data[0]# 最大值 放到堆的最後下標,最後下標的值調整到最高位置
25         sift_q(data,0,i-1)#調整出 除了最後下標 堆調整    排序完成
26 
27 #堆排序 降序
28 @cal_time
29 def sift_r(data):
30     n=len(data)
31     for i in range(n//2-1,-1,-1): #最後的父節點, 步長, 最前面
32         sift_q(data,i,n-1)#進行調整
33     list=[]
34     for i in range(n-1,-1,-1):# i指向堆的最後下標
35         list.append(data[0])#加入列表
36         data[0]=data[i]#最後下標的值調整到最高位置
37         sift_q(data,0,i-1)#調整出 除了最後下標 堆調整    排序完成i
38     data[0:n]=list
#歸並排序

 1 #歸並排序  合並
 2 def merge(list,low,mid,high):#列表,最左下標,中間下標,最右下標
 3     i=low #左邊指向下標
 4     j=mid+1 #右邊指向下標
 5     ltmp=[]#臨時列表
 6     while i<=mid and j<=high:#兩邊都還有數時
 7         if list[i]<list[j]:
 8             ltmp.append(list[i])#添加到臨時列表
 9             i+=1 #左邊指向下標右移
10         else:
11             ltmp.append(list[j])#添加到臨時列表
12             j+=1#右邊指向下標右移
13     while i<=mid:#如果左邊還有數時
14         ltmp.append(list[i])
15         i+=1
16     while j<=high:#如果右邊還有數時
17         ltmp.append(list[j])
18         j+=1
19     list[low:high+1]=ltmp  #寫回原的列表
20 
21 #歸並排序
22 def mergesort_q(li,low,high):
23     if low<high:
24         mid=(low+high)//2 #取中間值
25         mergesort_q(li,low,mid) #左邊分解
26         mergesort_q(li,mid+1,high) #右邊分解
27         merge(li,low,mid,high)#歸並排序
28 
29 @cal_time
30 def mergesort(data):
31     return mergesort_q(data,0,len(data)-1)
#希爾排序
 1 def _shell_sort(li):
 2     gap =len(li)//2 #分組的數
 3     while gap>=1:
 4         for i in range(gap,len(li)): #分組對比
 5             tmp=li[i]#取出要對比的數
 6             j=i-gap #前一組的對比數 下標
 7             while j>=0 and tmp< li[j]: #如果前一組有數, 並且大於後一組,
 8                 li[j+gap]=li[j] #進行,前一組位置的值換到後一組
 9                 j-=gap #下標向左移一組
10             li[i-gap]=tmp # 對比的數,換到前一組
11         gap =gap//2 #分組減半
12 
13 @cal_time
14 def shell_sort(li):
15     return _shell_sort(li)
#計數排序   只能用於數字排序 且是數字的一定範圍內
 1 def _count_sort(li,max_num):
 2     count=[0 for i in range(max_num+1)]#開一個列表  數字的範圍內的
 3     for num in li:#如果數字在數列中
 4         count[num]+=1  #計數加1
 5     i=0
 6     for num ,m in enumerate(count):#下標與數值
 7         for j in range(m): #輸出到原來的列表中
 8             li[i]=num  #
 9             i+=1 #下標右移
10 
11 @cal_time
12 def count_sort(li):
13     return _count_sort(li,len(li)-1)
#TOP排行
 1 #TOP排行
 2 def topk(li,k):
 3     ltmp=li[0:k+1]#取top數 多一位
 4     insert_sort(ltmp)#插入排序
 5     for i in range(k+1,len(li)):# 從取數的後一位開始
 6         ltmp[k]=li[i] #列表最後 改為下一個數
 7         tmp=ltmp[k] #臨時值
 8         j=k-1 #下標左移
 9         while j>=0 and ltmp[j] >tmp:#判斷
10             ltmp[j+1]=ltmp[j]# 數值 右移
11             j-=1 #左移一位下標
12         ltmp[j+1]=tmp #插入位置
13     return ltmp[0:k]# 返回所需的列表
14 #TOP排行
15 def topk_2(li,k):
16     ltmp=li[0:k+1]#取top數 多一位
17     insert_sort(ltmp)#插入排序
18     for i in range(k+1,len(li)):# 從取數的後一位開始
19         ltmp[k]=li[i]#列表最後 改為下一個數
20         insert(ltmp,k)
21     return ltmp[:-1]# 返回所需的列表
#堆top
 1 #堆top
 2 def topn(li,n):
 3     heap=li[0:n]#取top數
 4     for i in range(n//2-1,-1,-1):#建堆,小根堆
 5         sift_q(heap,i,n-1)#調整
 6     #進行遍歷
 7     for i in range(n,len(li)):
 8         if li[i] < heap[0]: #如果取來對比的數比根的小
 9             heap[0] =li[i]#進行替換
10             sift_q(heap,0,n-1)#調整
11     for i in range(n-1,-1,-1):
12         heap[0],heap[i] =heap[i],heap[0]# 最大值 放到堆的最後下標,最後下標的值調整到最高位置
13         sift_q(heap,0,i-1)#調整出 除了最後下標 堆調整    排序完成
14     return heap
1 data =list(range(100))#生成列表
2 random.shuffle(data)#打亂

python 第二百零八天 ----算法相關