基本思想:每步將一個待排序的紀錄,按其關鍵碼值的大小插入前面已經排序的文件中適當位置上,直到全部插入完為止。
def insertSort(arr):
if len(arr) <= 1:
return arr
for i in range(1, len(arr)):
tmp = arr[i]
j = i
while j > 0 and tmp < arr[j-1]:
arr[j] = arr[j-1]
j -= 1
a[j] = tmp
基本思想:先將要排序的一組記錄按某個增量d(n/2,n為要排序數的個數)分成若干組子序列,每組中記錄的下標相差d.對每組中全部元素進行直接插入排序,然后再用一個較小的增量(d/2)對它進行分組,在每組中再進行直接插入排序。繼續不斷縮小增量直至為1,最后使用直接插入排序完成排序。
def shellSort(arr):
if len(arr) <= 1:
return arr
Increment = len(arr) / 2
while Increment > 0:
for i in range(Increment, len(arr)):
tmp = arr[i]
j = i
while j > 0 and tmp < arr[j-Increment]:
arr[j] = arr[j-Increment]
j -= Increment
arr[j] = tmp
Increment /= 2
基本思想:每一次從待排序的數據元素中選出最小(或最大)的一個元素,存放在序列的起始位置,直到全部待排序的數據元素排完。
過程:
第一趟,從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換;
第二趟,從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換;
以此類推…..
第i 趟,則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換,
直到整個序列按關鍵碼有序。
def selectSort(arr):
if len(arr) <= 1:
return arr
for i in range(len(arr)-1):
min = i
for j in range(i+1, len(arr)):
if arr[j] < arr[min]:
min = j
arr[i], arr[min] = arr[min], arr[i]
基本思想:堆排序需要兩個過程,一是建立堆,二是堆頂與堆的最后一個元素交換位置.
堆排序會將所有的數據建成一個堆,最大的數據在堆頂,然后將堆頂數據和序列的最后一個數據交換。接下來不動最后一個數據再次重建堆,交換數據,依次下去,就可以排序所有的數據。
def heapSort(arr):
def precDown(a, i, N):
child = 2 * i + 1
tmp = a[i]
while child < N:
if child < N-1 and a[child] < a[child+1]:
child += 1
if tmp < a[child]:
a[i] = a[child]
i = child
else:
break
child = child * 2 + 1
a[i] = tmp
if len(arr) <= 1:
return arr
N = len(arr)
for i in range((N-2)//2, -1, -1):
precDown(arr,i,N)
for i in range(N-1, 0, -1):
arr[0], arr[i] = arr[i], arr[0]
precDown(arr,0,i)
基本思想:
def bubbleSort(arr):
length = len(arr)
if length <= 1:
return arr
while length > 1:
for i in range(length-1):
if arr[i] > arr[i+1]:
arr[i], arr[i+1] = arr[i+1], arr[i]
length -= 1
基本思想:使用一個樞紐元,通過一趟排序將要排序的數據分割成獨立的兩部分,其中一部分的所有數據都比樞紐元小,另外一部分的所有數據都比樞紐元大,然后再按此方法對這兩部分數據分別進行快速排序。
def quickSort(arr):
def Qsort(a, left, right):
i = left
j = right
if i >= j:
return
key = Median(a, left, right)
while i < j:
while i < j and a[j] >= key:
j -= 1
a[i] = a[j]
while i < j and a[i] <= key:
i += 1
a[j] = a[i]
a[i] = key
Qsort(a, left, i-1)
Qsort(a, i+1, right)
def Median(a, left, right):
center = (left + right) / 2
if a[left] > a[center]:
a[left], a[center] = a[center], a[left]
if a[center] > a[right]:
a[center], a[right] = a[right], a[center]
if a[left] > a[right]:
a[left], a[right] = a[right], a[left]
a[center], a[left] = a[left], a[center]
return a[left]
if len(arr) <= 1:
return arr
Qsort(arr, 0, len(arr)-1)
基本思想:將兩個(或兩個以上)有序表合並成一個新的有序表,即把待排序序列分為若干個子序列,每個子序列是有序的。然后再把有序子序列合並為整體有序序列。
def mergeSort(arr):
def Merge(left, right):
i, j = 0, 0
result = []
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
if len(arr) <= 1:
return arr
center = len(arr) / 2
left = mergeSort(arr[:center])
right = mergeSort(arr[center:])
return Merge(left, right)
基本思想:將所有待比較數值(正整數)統一為同樣的數位長度,數位較短的數前面補零。然后,從最低位開始,依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后, 數列就變成一個有序序列。
def bucketSort(arr, radix=10):
if len(arr) <= 1:
return arr
K = int(math.ceil(math.log(max(arr), radix)))
bucket = [[] for i in range(radix)]
for i in range(1, K+1):
for element in arr:
bucket[element%(radix**i)/(radix**(i-1))].append(element)
del(arr[:])
for each in bucket:
arr.extend(each)
bucket = [[] for i in range(radix)]
本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。