選擇排序算法：
a=[6,5,4,3,2,1]
算法思路：
第一步：在列表的第一個位置存放此隊列的最小值
聲明一個變量min_index等於列表的第一個坐標值0
從第一個位置0坐標開始，和它后邊所有的元素一一比對，如果發生了后邊的值min_index坐標的對應的值更小，則min_index值改為后邊那個數的坐標，然后用min_index坐標對應的值再跟后邊的數比較，完成全部比對以后，將列表的第一個數和min_index坐標對應的數做一個交換
第一次用6和5比較，5小，min_index改為1，用5和后邊的4比，4小，min_index改為2，用4跟3比，3小，min_index改為3，用3跟2比較，2小，min_index改為4，用2和1比較，1小，min_index改為5，比完了，把坐標5對應的值和第一個值交換
min_index=5
a=[1, 5, 4, 3, 2, 6]，最小的1放到最前邊，
第二步：從坐標1開始，把剛才的邏輯再來一遍：
a=[1, 2, 4, 3, 5, 6]
第三步：從坐標2開始，把剛才的邏輯再來一遍
a=[1, 2, 3, 4, 5, 6]
第四步：從坐標3開始，把剛才的邏輯再來一遍
a=[1, 2, 3, 4, 5, 6]
第五步：從坐標4開始，把剛才的邏輯再來一遍
a=[1, 2, 3, 4, 5, 6]
代碼實：第一步找最小的值
#encoding=utf-8
a=[6,5,4,3,2,1]
min_index=0
for i in range(1,len(a)):
if a[min_index]>a[i]:
min_index=i
print min_index
a[0],a[min_index]=a[min_index],a[0]
print a
D:\測試資料\python課件\Python筆記>python task_test.py
5
[1, 4, 3, 2, 5,6]
接下來：加一個循環
#encoding=utf-8
a=[6,5,4,3,2,1]
min_index=0
for i in range(len(a)-1):
min_index=i #每次i變化時，將最小下標值改為i，將本次循環第一個位置的值
for j in range(i+1,len(a)):#和當前i元素之后的所有值進行比對
if a[min_index]>a[j]:
min_index=j#如果發生小於的情況，則把此數的坐標賦值於min_index
print min_index
#當所有數比較完畢之后，將i坐標值和當前循環找到的最小值進行交換
a[i],a[min_index]=a[min_index],a[i]
print a
結果：ok
D:\test_python>python test.py
i: 0
min_index: 1
min_index: 2
min_index: 3
min_index: 4
min_index: 5
a: [1, 5, 4, 3, 2, 6]
i: 1
min_index: 2
min_index: 3
min_index: 4
a: [1, 2, 4, 3, 5, 6]
i: 2
min_index: 3
a: [1, 2, 3, 4, 5, 6]
i: 3
a: [1, 2, 3, 4, 5, 6]
i: 4
a: [1, 2, 3, 4, 5, 6]
思路：
第一次：找到最小值，存到列表的0坐標位置
第二次：找到次小值，存到列表的1坐標位置
第三次：找到第三小的值，存到列表的2坐標位置
第四次：找到第四小的值，存到列表的3坐標位置
第五次：找到第五小的值，存到列表的4坐標位置
剩下的最后一個位置的數，就是最大值
時間復雜度是n^2，因為有兩個循環
選擇排序總結：
選擇排序的思路是固定位置，選擇排序，即：先從序列中，找到最小的元素，放到第一個位置，然后找到第二小的元素，放到第二個位置，以此類推，直到排好所有的值。
那么代碼無論怎么寫，只要是按照先找到最小的放到第一個位置，然后找第二個最小的值放到第二個位置這種思路，就是選擇排序算法的實現方式。
首先：實現找到最小的元素放到第一個位置
聲明一個變量min_index等於列表的第一個坐標值0
因為min_index是第一個位置，你么從第二個位置（1坐標）開始，和它后邊所有的元素一一比對，如果發生了后邊的值min_index坐標的對應值更小，則min_index坐標改為后邊那個數的坐標，
完成全部比對以后，將列表的第一個數和min_index坐標對應的數做一個交換
代碼：
#encoding=utf-8
a=[6,9,3,5,0,1,4,2,7]
min_index=0
for i in range(1,len(a)):
print "i:",i
if a[min_index] > a[i]:
min_index = i
print "min_index:",min_index
print min_index
a[0],a[min_index] = a[min_index],a[0]
print a
程序執行過程：
D:\test>python test.py
i: 1
i: 2
min_index: 2
i: 3
i: 4
min_index: 4
i: 5
i: 6
i: 7
i: 8
4
[0, 9, 3, 5, 6, 1, 4, 2, 7]
可以看到，當i從1開始走，遇到比min_index（初始值0）小的，就把min_index改為i；
比如第一次遇到比min_index=0的數小的時候，i是2，那么把min_index改為2；
然后i繼續走，遇到比min_index=2的值小的時候，i是4，那么把min_index改為4;
然后i繼續走，再和min_index=4的值比較。。。
最后走到8時，程序走完，此時就把最小的數的坐標給了min_index了；
然后把這個數和第一個數作交換，即a[0],a[min_index] = a[min_index],a[0]
至此，第一步就實現了
其次，從第二個數開始依次把第一步的邏輯走一遍
之后的關鍵點就是，從第二個數開始依次把第一步的邏輯走一遍
怎么走呢？
其實第一步循環的關鍵是先把min_value設為第一個數的坐標0
那么第二步就應該把min_value設為1，然后從坐標2開始往前遍歷，找到最小的數
第三步。。。設為2，坐標從3開始遍歷，找到最小的數
其實每一步min_value的值就是所遍歷的列表的第一個位置，在這個列表中，min_value就是最左邊的數，所以就是把同樣的邏輯在不同長度的列表中執行一遍
每次的區別就是列表的長度不同，就是原來列表右坐標不動，左坐標依次遞增
那么這個過程就可以用兩層循環來做
第一層循環用i從左到右遍歷列表a
當i遍歷到某個位置時，執行第一次的循環邏輯，把首位數坐標i賦值給min_value
冒泡排序和選擇排序的邏輯是相反的
代碼：
#encodjng=utf-8
a=[6,9,3,5,0,1,4,2,7]
for i in range(len(a)-1):
min_index=i
print "i:",i
for j in range(i+1,len(a)):
print " j:",j
if a[min_index] > a[j]:
min_index = j
print " min_index:","\033[1;32;40m %s \033[0m" %min_index
print " min_index:",min_index
a[i],a[min_index] = a[min_index],a[i]
print " a:",a
print "a:",a
代碼執行過程：
D:\test>python test.py
i: 0
j: 1
j: 2
min_index: [1;32;40m 2 [0m
j: 3
j: 4
min_index: [1;32;40m 4 [0m
j: 5
j: 6
j: 7
j: 8
min_index: 4
a: [0, 9, 3, 5, 6, 1, 4, 2, 7]
i: 1
j: 2
min_index: [1;32;40m 2 [0m
j: 3
j: 4
j: 5
min_index: [1;32;40m 5 [0m
j: 6
j: 7
j: 8
min_index: 5
a: [0, 1, 3, 5, 6, 9, 4, 2, 7]
i: 2
j: 3
j: 4
j: 5
j: 6
j: 7
min_index: [1;32;40m 7 [0m
j: 8
min_index: 7
a: [0, 1, 2, 5, 6, 9, 4, 3, 7]
i: 3
j: 4
j: 5
j: 6
min_index: [1;32;40m 6 [0m
j: 7
min_index: [1;32;40m 7 [0m
j: 8
min_index: 7
a: [0, 1, 2, 3, 6, 9, 4, 5, 7]
i: 4
j: 5
j: 6
min_index: [1;32;40m 6 [0m
j: 7
j: 8
min_index: 6
a: [0, 1, 2, 3, 4, 9, 6, 5, 7]
i: 5
j: 6
min_index: [1;32;40m 6 [0m
j: 7
min_index: [1;32;40m 7 [0m
j: 8
min_index: 7
a: [0, 1, 2, 3, 4, 5, 6, 9, 7]
i: 6
j: 7
j: 8
min_index: 6
a: [0, 1, 2, 3, 4, 5, 6, 9, 7]
i: 7
j: 8
min_index: [1;32;40m 8 [0m
min_index: 8
a: [0, 1, 2, 3, 4, 5, 6, 7, 9]
a: [0, 1, 2, 3, 4, 5, 6, 7, 9]
可以看到加了一層循環是把上一步的邏輯依從從第一個位置到最后一個位置執行了一遍，
第一層循環是控制i從0到len(a)-1一次遞增，每次遞增為1；
第二層是當i前進一步時，i不動，j在i之后的所有序列中找到最小的數，放到i的位置（j所遍歷序列的第一個位置），即走一遍第一步的代碼邏輯，然后第二層循環結束（此時i所在位置之前的數已經是排好序的了）；
然后回到第一層循環，把i往前移動一個，再走一遍第一步的查找最小數的邏輯，放到i的位置（j所遍歷的序列的第一個位置）