1，把第乙個元素與第二個元素比較，如果第乙個比第二個大，則交換他們的位置。接著繼續比較第二個與第三個元素，如果第二個比第三個大，則交換他們的位置….
2，對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣一趟比較交換下來之後，排在最右的元素就會是最大的數。
3，除去最右的元素，對剩餘的元素做同樣的工作，重複1，2，如此重複下去，直到排序完成。
def bubblesort(arr):
for i in range(len(arr)-1,0,-1):
for j in range(0,i):
if arr[j]> arr[j+1]:
temp=arr[j]
arr[j]=arr[j+1]
arr[j+1]=temp
return arr
array=[3,6,3,8,9,1,10]
print(bubblesort(array))
首先，找到陣列中最小的那個元素，其次，將它和陣列的第乙個元素交換位置(如果第乙個元素就是最小元素那麼它就和自己交換)。其次，在剩下的元素中找到最小的元素，將它與陣列的第二個元素交換位置。如此往復，直到將整個陣列排序。
def selectsort(arr):
for i in range(0,len(arr)):
for j in range(i+1,len(arr)):
if arr[i]>arr[j]:
temp=arr[i]
arr[i]=arr[j]
arr[j]=temp
return arr
array=[3,6,4,8,9,1,0]
t=selectsort(array)
print(t)
1、從陣列第2個元素開始抽取元素。
2、把它與左邊第乙個元素比較，如果左邊第乙個元素比它大，則繼續與左邊第二個元素比較下去，直到遇到不比它大的元素，然後插到這個元素的右邊。
3、繼續選取第3，4，….n個元素,重複步驟 2 ，選擇適當的位置插入。
def insertsort(arr):
for i in range(1,len(arr)):
for j in range(i,0,-1):
if arr[j]性質：時間複雜度：o(n2) ；空間複雜度：o(1) ；穩定排序 ；原地排序
希爾排序的思想是採用插入排序的方法，先讓陣列中任意間隔為 h 的元素有序，剛開始 h 的大小可以是 h = n / 2,接著讓 h = n / 4，讓 h 一直縮小，當 h = 1 時，也就是此時陣列中任意間隔為1的元素有序，此時的陣列就是有序的了。
注意：對各個分組進行插入的時候並不是先對乙個組排序完了再來對另乙個組排序，而是輪流對每個組進行排序。
希爾排序可以說是插入排序的一種變種。無論是插入排序還是氣泡排序，如果陣列的最大值剛好是在第一位，要將它挪到正確的位置就需要 n - 1 次移動。也就是說，原陣列的乙個元素如果距離它正確的位置很遠的話，則需要與相鄰元素交換很多次才能到達正確的位置，這樣是相對比較花時間了。
希爾排序就是為了加快速度簡單地改進了插入排序，交換不相鄰的元素以對陣列的區域性進行排序。
def insertsort(arr):
gap=len(arr)//2
while gap>0:
for i in range(gap, len(arr)):
for j in range(i, 0, -gap):
if j >= gap and arr[j] < arr[j - gap]:
temp = arr[j]
arr[j] = arr[j - gap]
arr[j - gap] = temp
gap//=2
return arr
a = list(input("input some numbers:"))
print (a)
print(insertsort(a))
def shellsort(ar):
n=len(ar)
g=n//2
while g>0:
ar=insertsort(ar,g)
g//=2
return ar
#類似插入排序
def insertsort(arr,gap):
for i in range(gap, len(arr)):
for j in range(i, 0, -gap):
if j >= gap and arr[j] < arr[j - gap]:
temp = arr[j]
arr[j] = arr[j - gap]
arr[j - gap] = temp
return arr
a = list(input("input some numbers:"))
print (a)
print(shellsort(a))
將乙個大的無序陣列有序，先把大的陣列分成兩個，然後對這兩個陣列分別進行排序，之後再把這兩個陣列合併成乙個有序的陣列。由於兩個小的陣列都是有序的，所以在合併的時候是很快的。
通過遞迴的方式將大的陣列一直分割，直到陣列的大小為 1，此時只有乙個元素，那麼該陣列就是有序的了，之後再把兩個陣列大小為1的合併成乙個大小為2的，再把兩個大小為2的合併成4的 …… 直到全部小的陣列合併起來。即：先遞迴分解陣列，再合併陣列
def mergesort(ar):
if len(ar)<=1:
return ar
num=len(ar)//2
left=mergesort(ar[:num])
right=mergesort(ar[num:])
return merge(left,right)
def merge(left,right):
result=
l, r=0, 0
while l性質：時間複雜度：o(nlogn) ；空間複雜度：o(n) ；穩定排序 ；非原地排序
我們從陣列中選擇乙個元素，我們把這個元素稱之為中軸元素吧，然後把陣列中所有小於中軸元素的元素放在其左邊，所有大於或等於中軸元素的元素放在其右邊，顯然，此時中軸元素所處的位置的是有序的。也就是說，我們無需再移動中軸元素的位置。
從中軸元素那裡開始把大的陣列切割成兩個小的陣列(兩個陣列都不包含中軸元素)，接著我們通過遞迴的方式，讓中軸元素左邊的陣列和右邊的陣列也重複同樣的操作，直到陣列的大小為1，此時每個元素都處於有序的位置。
def quicksort(arr,s,e):
if s>=e:
return
flag=s
for i in range(flag+1,e+1):
if flagarr[i]:
temp=arr[i]
del arr[i]
arr.insert(flag,temp)
flag+=1
# quicksort(arr[:flat-1],0,flat-1)
# quicksort(arr[flat+1:], 0, flat+1)
quicksort(arr, s, flag - 1) # 將基準的 前後部分分別遞迴排序
quicksort(arr, flag + 1, e)
return arr
a = list(input("input some numbers:"))
print (a)
print(quicksort(a,0,len(a)-1))
術語解釋：
1、穩定排序：如果 a 原本在 b 的前面，且 a == b，排序之後 a 仍然在 b 的前面，則為穩定排序。
2、非穩定排序：如果 a 原本在 b 的前面，且 a == b，排序之後 a 可能不在 b 的前面，則為非穩定排序。
3、原地排序：原地排序就是指在排序過程中不申請多餘的儲存空間，只利用原來儲存待排資料的儲存空間進行比較和交換的資料排序。
4、非原地排序：需要利用額外的陣列來輔助排序。
5、時間複雜度：乙個演算法執行所消耗的時間。
6、空間複雜度：執行完乙個演算法所需的記憶體大小。
經典排序演算法（Python實現）
氣泡排序 演算法思想 公升序排序 第一次遍歷，依次比較相鄰兩個元素的大小，大的放後面小的放前面，找到最大的元素排在最後，以此類推遍歷n 1次。def bubblesort array length len array for i in range length for j in range leng...
經典排序演算法 選擇排序 python實現
選擇排序 selection sort 是一種簡單直觀的排序演算法。它的工作原理 首先在未排序序列中找到最小 大 元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小 大 元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。演算法描述 n個記錄的直接選擇排序可經過n ...
用python實現基本的排序
氣泡排序 def sort alist for j in range len alist 1 for i in range len alist 1 j if alist i alist i 1 alist i alist i 1 alist i 1 alist i return alist 選擇排序...