【python数据结构与算法】几种排序算法：冒泡排序、快速排序

以下排序算法，默认的排序结果是从小到大。

一.冒泡排序：

1.冒泡排序思想：越大的元素，就像越大的气泡。最大的气泡才能够浮到最高的位置。

具体来说，即，冒泡排序有两层循环，外层循环控制每一轮排序中操作元素的个数——冒泡排序每一轮都会找到遍历到的元素的最大值，并把它放在最后，下一轮排序时便不再遍历它；

内层循环是根据数值大小来交换数对——谁更大，谁就会被换到后面去。

2.代码如下：

def bubble_sort(alist):
    for i in range(len(alist)-1,0,-1):
        count = 0
        for j in range(i):
            if alist[j] > alist[j+1]:
                count += 1
                alist[j],alist[j+1] = alist[j+1],alist[j]
        if count == 0:     # 如果遍历所有待排序元素后发现，数对交换从未发生，那么意味着数列是有序的，后面不需要再排序了
            break
    return alist



aa = [6,1,2,7,9,3,4,5,10,8]
bubble_sort(aa)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

二.快速排序：

1.快排思想：

• 1.lo/hi是两个游标，分别从列表的两端开始移动（hi先动），其中，把lo最初对应的数称作key，也就是列表第一个数是key；
• 2.把hi发现的小于key的数给lo；把lo发现的大于等于key的数给hi；
• 3.然后，当lo == hi时，将key赋值给lo、hi俩游标指向的那个数；
• 4.最后，按照key现在的位置，将列表切分成前后两段，再次按照上面的程序来，最终完成所有数字的排序
• 注意：第三步不会丢失某个元素，因为如果hi从尾到头没有找到比key小的元素就因为hi=lo这个条件无法进入循环，那么整个过程就没进入过循环，也就不会出现数值交换，最终，key把它赋给了它自己；如果lo、hi中途有停顿最终相遇，那么如果是hi找到lo，则lo位置上的数值现在保存在hi动之前的位置上；如果是lo找到的hi，则hi位置上的数值是保存在lo动之前的位置。

2.代码，如下：

def qSort(alist,first,last):
    if first >= last:
        return
    
    key = alist[first]
    lo = first
    hi = last
    
    while lo < hi:
        while lo < hi and key <= alist[hi]:
            hi -= 1
        alist[lo] = alist[hi]
        
        while lo < hi and key > alist[lo]:
            lo += 1
        alist[hi] = alist[lo]
        
    alist[lo] = key
    
    qSort(alist,first,lo-1)
    qSort(alist,lo+1,last)


bb = [6,1,2,7,9,3,4,5,10,8]
qSort(bb,0,len(bb)-1)
bb
>>>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]