#氣泡排序#基本思想：兩兩相鄰記錄的關鍵字，如果反序則交換，直到沒有反序的記錄為止
#要點：1.兩兩注意是相鄰的兩個元素的意思
# 2.如果有n個元素需要比較n-1次，每一輪減少1次比較
# 3.既然叫氣泡排序，那就是從下往上兩兩比較，所以看上去就跟泡泡往上冒一樣。
def bubblesort(numlist):
leng = len(numlist)-1
for i in range(leng): #i=0
for j in range(leng-i):#j=0,1,2,3,4,5,6
if numlist[leng-j] < numlist[leng-j-1]:#leng-j=6,leng-j-1=5
midnum = numlist[leng-j]
numlist[leng-j] = numlist[leng-j-1]
numlist[leng-j-1] = midnum
print(numlist)
return numlist
print(bubblesort([1,2,-1,8,6,7,-2]))
# [-2, 1, 2, -1, 8, 6, 7] 索引0~索引6，從後往前,相鄰元素兩兩相比，如果錯位，進行元素互換
# [-2, -1, 1, 2, 6, 8, 7] 索引0~索引5，從後往前,相鄰元素兩兩相比，如果錯位，進行元素互換
# [-2, -1, 1, 2, 6, 7, 8] 索引0~索引4，從後往前,相鄰元素兩兩相比，如果錯位，進行元素互換
# [-2, -1, 1, 2, 6, 7, 8] 索引0~索引3，從後往前,相鄰元素兩兩相比，如果錯位，進行元素互換
# [-2, -1, 1, 2, 6, 7, 8] 索引0~索引2，從後往前,相鄰元素兩兩相比，如果錯位，進行元素互換
# [-2, -1, 1, 2, 6, 7, 8] 索引0~索引1，從後往前,相鄰元素兩兩相比，如果錯位，進行元素互換
#插入排序
#基本思想：將乙個記錄插入到已經排好序的有序表中，從而得到乙個新的、記錄數增加1的有序表。
def insertsort(numlist):
leng = len(numlist)
for i in range(1,leng):
if numlist[i] < numlist[i-1]:
midnum = numlist[i]
for j in range(i):
if numlist[i-j-1]>midnum:
numlist[i-j] = numlist[i-j-1]
numlist[i-j-1] = midnum
print(numlist)
return numlist
print(insertsort([1,2,-1,8,6,7,-2]))
# [1, 2, -1, 8, 6, 7, -2] 從原始陣列中，從索引1開始，與索引0元素相比，如果遇到錯位的，把這個索引的值插到正確的位置
# [-1, 1, 2, 8, 6, 7, -2] 繼上次更改資料，從索引2開始，與索引1元素相比，如果遇到錯位的，把這個索引的值插到正確的位置
# [-1, 1, 2, 8, 6, 7, -2] 繼上次更改資料，從索引3開始，與索引2元素相比，如果遇到錯位的，把這個索引的值插到正確的位置
# [-1, 1, 2, 6, 8, 7, -2] 繼上次更改資料，從索引4開始，與索引3元素相比，如果遇到錯位的，把這個索引的值插到正確的位置
# [-1, 1, 2, 6, 7, 8, -2] 繼上次更改資料，從索引5開始，與索引4元素相比，如果遇到錯位的，把這個索引的值插到正確的位置
# [-2, -1, 1, 2, 6, 7, 8] 繼上次更改資料，從索引6開始，與索引5元素相比，如果遇到錯位的，把這個索引的值插到正確的位置
#選擇排序
#基本思想：通過n-i次關鍵字間的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i(1<=i<=n)個記錄交換。
def selectsort(numlist):
leng = len(numlist)
for i in range(leng-1):
temp_min = numlist[i+1]
j_index = i+1
for j in range(i+1,leng):
if numlist[j] < temp_min:
temp_min = numlist[j]
j_index = j
if numlist[i] > temp_min:
temp = numlist[i]
numlist[i] = temp_min
numlist[j_index] = temp
print(numlist)
return numlist
print(selectsort([1,2,-1,8,6,7,-2]))
# [-2, 2, -1, 8, 6, 7, 1] 從原始陣列中，記索引0的值為s,找出索引1~索引6最小值t，如果s>t，則交換兩個值
# [-2, -1, 2, 8, 6, 7, 1] 繼上次更改資料，記索引1的值為s,找出索引2~索引6最小值t，如果s>t，則交換兩個值
# [-2, -1, 1, 8, 6, 7, 2] 繼上次更改資料，記索引2的值為s,找出索引3~索引6最小值t，如果s>t，則交換兩個值
# [-2, -1, 1, 2, 6, 7, 8] 繼上次更改資料，記索引3的值為s,找出索引4~索引6最小值t，如果s>t，則交換兩個值
# [-2, -1, 1, 2, 6, 7, 8] 繼上次更改資料，記索引4的值為s,找出索引5~索引6最小值t，如果s>t，則交換兩個值
# [-2, -1, 1, 2, 6, 7, 8] 繼上次更改資料，記索引5的值為s,找出索引6~索引6最小值t，如果s>t，則交換兩個值
#快速排序：
#基本思想：遞迴思想，在每次呼叫時都將第乙個元素作為基準，把所有小於這個數的數放左邊，大於這個數的數放右邊
def swap(numlist, low, high):
temp = numlist[low]
numlist[low] = numlist[high]
numlist[high] = temp
def partition(numlist, low, high):
point = numlist[low]
while low < high:
while low= point:
high -= 1
swap(numlist, low, high)
while low[66] [81, 69, 76]
# [13, 23, 51, 57, 26, 66, 81, 69, 76] [13] [23] [51, 57, 26] [66] [81, 69, 76]
# [13, 23, 26, 51, 57, 66, 81, 69, 76] [13] [23] [26] [51] [57] [66] [81, 69, 76]
# [13, 23, 26, 51, 57, 66, 76, 69, 81] [13] [23] [26] [51] [57] [66] [76, 69] [81]
# [13, 23, 26, 51, 57, 66, 69, 76, 81] [13] [23] [26] [51] [57] [66] [69] [76] [81] low=high=6，終止
python 排序演算法（一）氣泡排序
氣泡排序演算法的原理如下 比較相鄰的元素。如果第乙個比第二個大，就交換他們兩個。對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。針對所有的元素重複以上的步驟，除了最後乙個。持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較 for ...
python實現排序演算法一 快速排序
快速排序演算法 基本思想 分治法，將陣列分為大於和小於該值的兩部分資料，然後在兩部分資料中進行遞迴排序，直到只有乙個資料結束 step1 取陣列第乙個元素為key值，設定兩個變數，i 0,j len a 1 step2 j從後面開始遍歷，遇到小於key的值，則a i a j step3 i從前面開始...
排序演算法總結 Python實現 一
整個排序演算法分兩部分來總結，這篇總結第一部分一些相對簡單和常用的排序演算法，包括氣泡排序 選擇排序 插入排序和希爾排序。氣泡排序應該是大家接觸的最早的排序方法了，理解起來也十分簡單。氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走...