Python笔记-排序算法实现（1）

排序是数据结构中常用的方法，现用Python实现起泡排序和选择排序。

将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

冒泡排序是就地排序，且它是稳定的。
（1）初始
　  R[1..n]为无序区。
（2）第一趟扫描
　  从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n- 1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换 R[j+1]和R[j]的内容。
    第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。
（3）第二趟扫描
　  扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……
    最后，经过n-1 趟扫描可得到有序区R[1..n]
  注意：
　  第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。

Python 实现：

def bubbleSort(L):
    size = len(L)
    for i in range(size-1):
        count = 0
        for j in range(size-i-1):
            if L[j]>L[j+1]:
                temp = L[j]
                L[j]=L[j+1]
                L[j+1] = temp
                count += 1
        print(L)
        if count == 0:
            break

L = [1,4,6,9,2,0,3,8,7,5]
print L
bubbleSort(L)
    

结果如下：

此外，起泡排序是稳定排序，其时间复杂度为O(n^2)，空间复杂度为O(1)。在最好的情况下，即数组基本有序时，时间复杂度为O(n)。

此外，选择排序也是简单排序中的一种，不过比起泡排序的效率要高，并且也比较容易实现。

基本思想

 

　　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

　　选择排序是不稳定的排序方法。n个记录的文件的直接选择排序可经过n－1趟直接选择排序得到有序结果：

 

　　①初始状态：无序区为R[1．．n]，有序区为空。

 

　　②第1趟排序

 在无序区R[1．．n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1．．1]和R[2．．n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

　　……

 

　　③第i趟排序

　　第i趟排序开始时，当前有序区和无序区分别为R[1．．i－1]和R（1≤i≤n－1）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1．．i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

 

　　这样，n个记录的文件的直接选择排序可经过n－1趟直接选择排序得到有序结果。

 

　　【示例】：

 

　　初始关键字 [49 38 65 97 76 13 27 49]

第一趟排序后 13 ［38 65 97 76 49 27 49]

 

　　第二趟排序后 13 27 ［65 97 76 49 38 49]

 

　　第三趟排序后 13 27 38 [97 76 49 65 49]

 

　　第四趟排序后 13 27 38 49 [49 97 65 76]

 

　　第五趟排序后 13 27 38 49 49 [97 65 76]

 

　　第六趟排序后 13 27 38 49 49 65 [97 76]

 

　　第七趟排序后 13 27 38 49 49 76 [97 76]

 

　　最后排序结果 13 27 38 49 49 76 76 97

Python实现：

<span style="font-size:12px;">def selectSort(L):
    size = len(L)
    for i in range(0,size):
        min=L[i]
        index = i
        for j in range(i,size):
            if L[j] < min:
                min=L[j]
                index=j
        temp=L[i]
        L[i]=min
        L[index]=temp
        print(L)

L = [1,4,6,9,2,0,3,8,7,5]

print L
selectSort(L)
</span>

结果如图。

此外，选择排序是不稳定排序，在最好和最坏的情况下其时间复杂度为O(n^2)，空间复杂度为O(1)。