'''
插入排序的基本操作是將壹個數據插入到有序數據中，從而得到壹個編號加壹的新的有序數據。該算法適合對少量數據進行排序，時間復雜度為O (n 2)。是壹種穩定的排序方法。
插入算法將要排序的數組分成兩部分:
第壹部分包含這個數組的所有元素，除了最後壹個元素(讓數組多壹個空間來插入)
第二部分只包含這個元素(即要插入的元素)。
第壹部分排序後，將最後壹個元素插入排序後的第壹部分。
'''
def insert_sort(列表):
#插入排序
count = len(列表)
對於範圍內的I(1，計數):
key =列表[i]
j = i - 1
而j & gt= 0:
if列表[j]& gt；關鍵:
列表[j + 1] =列表[j]
列表[j] =鍵
j -= 1
返回列表
'''
外殼排序是插入排序的壹種。也稱為縮減增量排序，它是直接插入排序算法的更高效和改進版本。希爾排序是壹種不穩定的排序算法。這種方法是由dl提出後命名的。殼牌在1959。
Hill排序是將記錄按照目標的壹定增量進行分組，使用直接插入排序算法對每組進行排序；隨著增量逐漸減小，每個組包含的關鍵詞越來越多。當增量減少到1時，整個文件正好分成壹組，算法終止。
'''
def shell_sort(列表):
#希爾排序
count = len(列表)
步驟= 2
組=計數/步
while group & gt0:
對於範圍內的I(0，組):
j = i +組
而j & lt計數:
k = j -群
key =列表[j]
而k & gt= 0:
if列表[k]& gt；關鍵:
列表[k +組] =列表[k]
列表[k] =鍵
k -=組
j +=組
group /= step
返回列表
'''
冒泡排序已經反復訪問了要排序的序列，壹次比較兩個元素，如果它們的順序錯了就交換。訪問系列的工作壹直重復，直到不需要交換為止，也就是說系列已經排序了。
'''
定義冒泡_排序(列表):
#冒泡排序
count = len(列表)
對於範圍內的I(0，計數):
對於範圍內的j(I+1，計數):
if列表[I]& gt；列表[j]:
temp = lists[j]
列表[j] =列表[i]
列表[i] =臨時
返回列表
'''
快速排序
通過壹次排序將待排序的數據分成兩個獨立的部分，其中壹部分的所有數據都小於另壹部分，然後按照這種方法對這兩部分數據進行快速排序，整個排序過程可以遞歸進行，從而實現整個數據成為壹個有序序列。
'''
def quick_sort(列表，左，右):
#快速排序
如果離開& gt=右:
返回列表
key =列表[左]
低=左
高=右
同時離開& lt右:
同時離開& lt權限和列表[權限]& gt；=鍵:
右-= 1
列表[左] =列表[右]
同時離開& lt右和列表[左]& lt；=鍵:
left += 1
列表[右] =列表[左]
列表[右] =鍵
quick_sort(列表，低位，左- 1)
quick_sort(列表，左+ 1，高)
返回列表
'''
直接選擇排序
傳遞1，從要排序的記錄中選擇最小的記錄，與r[1]交換；
第二遍，從待排序的記錄r[2] ~ r[n]中選擇最小的記錄，與r[2]交換；
以此類推，在第I遍待排序的記錄r[i] ~ r[n]中選擇最小的記錄，與r[i]交換，使有序序列不斷增長，直到所有記錄排序完畢。
'''
定義select_sort(列表):
#選擇排序
count = len(列表)
對於範圍內的I(0，計數):
最小值= i
對於範圍內的j(I+1，計數):
if列表[min]& gt；列表[j]:
最小值= j
temp =列表[分鐘]
列表[min] =列表[i]
列表[i] =臨時
返回列表
'''
Heapsort是指利用堆樹(heap)的數據結構設計的壹種排序算法，是壹種選擇性排序。
您可以使用數組的特征來快速定位指定索引的元素。堆分為大根堆和小根堆，是壹棵完整的二叉樹。大根堆的要求是每個節點的值不大於其父節點的值，即a[parent[I]]>；= A[i].
在非降序排列的數組中，需要根堆，因為根據根堆的要求，最大值必須在堆的頂部。
'''
#調整堆
def adjust_heap(列表，I，大小):
lchild = 2 * i + 1
rchild = 2 * i + 2
最大值= i
如果我& lt尺寸/ 2:
如果lchild & lt大小和列表[lchild]>列表[最大]:
max = lchild
如果rchild & lt大小和列表[rchild]& gt；列表[最大]:
max = rchild
如果max！=我:
列表[最大值]，列表[i] =列表[i]，列表[最大值]
adjust_heap(列表，最大值，大小)
#創建堆
def build_heap(列表，大小):
對於範圍內的I(0，(大小/2))[::-1]:
adjust_heap(列表，I，大小)
#堆排序
定義堆排序(列表):
size = len(列表)
build_heap(列表，大小)
對於範圍(0，大小)[::-1]中的I:
列表[0]，列表[i] =列表[i]，列表[0]
adjust_heap(lists，0，I)
'''
歸並排序是壹種基於歸並操作的有效排序算法，是分而治之的壹個非常典型的應用。合並有序子序列以獲得完全有序的序列；也就是說，首先對每個子序列進行排序，然後對子序列段進行排序。如果兩個有序表合並成壹個有序表，稱為雙向合並。
合並過程如下:
比較a[i]和a[j]的大小。若a[i]小於等於a [j]，則將第壹個有序表中的元素A [I]復制到r[k]中，I和K分別加1；
否則，將第二個有序表中的元素a[j]復制到r[k]中，並將J和K分別加1，以此類推，直到其中壹個有序表用完，再將另壹個有序表中剩余的元素復制到r中下標K到下標t的單元中，合並排序的算法通常是遞歸實現的。首先將待排序區間[s，t]用中點壹分為二，然後對左子區間排序，再對右子區間排序，最後通過壹次合並操作將左右區間合並為壹個有序區間[s，t]。
'''
定義合並(左、右):
I，j = 0，0
結果= []
而我& ltlen(左)和j & lt倫(右):
如果離開[I]& lt；= right[j]:
result.append(left[i])
i += 1
否則:
result.append(右[j])
j += 1
result += left[i:]
result += right[j:]
回送結果
定義合並排序(列表):
#合並排序
if len(列表)& lt= 1:
返回列表
num = len(列表)/ 2
left = merge_sort(列表[:數量])
right = merge_sort(lists[num:])
返回合並(左，右)
'''
基數排序屬於“分布排序”，也稱為“桶排序”或bin排序。顧名思義，它通過鍵值的壹些信息，將待排序的元素分布到壹些“桶”中，從而實現排序功能。基數排序屬於穩定排序。
它的時間復雜度為O (nlog(r)m)，其中r是采用的基數，m是堆號。在某些情況下，基數排序法的效率高於其他穩定排序法。
'''
導入數學
def radix_sort(列表，radix=10):
k = int(math . ceil(math . log(max(lists)，radix)))
bucket = [[] for i in range(radix)]
對於範圍內的I(1，k+1):
對於列表中的j:
bucket[j/(radix * *(I-1))%(radix * * I)]。追加(j)
刪除列表[:]
對於鏟鬥中的z:
列表+= z
del z[:]
返回列表
-
由CRazyDOgen
資料來源:CSDN
原文:/jipang 6225/文章/詳情/79975312
版權聲明:本文為博主原創文章，轉載請附上博客鏈接！