一、冒泡排序

二、选择排序

三、插入排序

四、希尔排序

五、归并排序

六、快速排序

排序是指将集合中的元素按照某种顺序排序的过程。

一、冒泡排序

冒泡排序多次遍历列表。它比较相邻的元素，将不合顺序的交换。每一轮遍历都将下一个最大值放到正确的位置上。本质上，每个元素通过“冒泡”找到自己所属的位置。

冒泡排序需要遍历的轮数是n-1，完成n-1轮后，最小的元素必然在正确的位置上，因此不必再做处理。

冒泡排序函数bubbleSort：

def bubbleSort(alist):
    for passnum in range(len(alist)-1,0,-1):
        for i in range(passnum):
            if alist[i]>alist[i+1]:
                temp=alist[i]
                alist[i]=alist[i+1]
                alist[i+1]=temp

Python允许同时赋值，执行语句a,b=b,a，相当于同时执行两条赋值语句。

冒泡排序算法中，给含有n个元素的列表排序总需要遍历n-1轮，总的比较次数是前n-1个整数之和，因此前n-1个整数之和就是 $\frac{1}{2}n^2-\frac{1}{2}n$ 。这表明，该算法的时间复杂度是 $O(n^2)$ 。在最好的情况下，列表是已经有序的，不需要执行交换操作。在最坏情况下，每一次比较都将导致一次交换。

冒泡排序通常被认为是效率最低的排序算法，因为在确定最终的位置前必须交换元素。“多余”的交换操作代价很大。不过，由于冒泡排序要遍历列表中未排序的部分，因此它具有其他排序算法没有的用途。特别是，如果在一轮遍历中没有发生元素交换，就可以确定列表已经有序。可以修改冒泡排序函数，使其在遇到这种情况时提前终止。对于只需要遍历几次的列表，冒泡排序可能有优势，因此它能判断出有序列表并终止排序过程。这种排序通常被称为短冒泡。

修改后的冒泡排序函数：

def shortBubbleSort(alist):
    exchanges=True
    passnum=len(alist)-1
    while passnum>0 and exchanges:
        exchanges=False
        for i in range(passnum):
            if alist[i]>alist[i+1]:
                exchanges=True
                temp=alist[i]
                alist[i]=alist[i+1]
                alist[i+1]=temp
        passnum=passnum-1

二、选择排序

选择排序在冒泡排序的基础上做了改进，每次遍历列表时只做一次交换。要实现这一点，选择排序在每次遍历时寻找最大值，并在遍历完之后将它放到正确位置上。和冒泡排序一样，第一次遍历后，最大的元素就位；第二次遍历后，第二大的元素就位，依此类推。若给n个元素排序，需要遍历n-1轮。

选择排序函数selectionSort：

def selectionSort(alist):
    for fillslot in range(len(alist)-1,0,-1):
        positionOfMax=0
        for location in range(1,fillslot+1):
            if alist[location]>alist[positionOfMax]:
                positionOfMax=location
        temp=alist[fillslot]
        alist[fillslot]=alist[positionOfMax]
        alist[positionOfMax]=temp

可以看出，选择排序算法和冒泡排序算法的比较次数相同，所以时间复杂度也是 $O(n^2)$ 。但是，由于减少了交换次数，因此选择排序算法通常更快。

三、插入排序

插入排序的时间复杂度也是 $O(n^2)$ ，但原理稍有不同。它在列表较低的一端维护一个有序的子列表，并逐个将每个新元素“插入”这个子列表。

首先假设位置0处的元素是只含单个元素的有序子列表。从元素1到元素n-1，每一轮都将当前元素与有序子列表中的元素进行比较。在有序子列表中，将比它大的元素右移；当遇到一个比他小的元素或抵达子列表终点时，就可以插入当前元素。

在给n个元素排序时，插入排序算法需要遍历n-1轮。循环从位置1开始，直到位置n-1结束，这些元素都需要被插入到有序子列表中。

插入排序函数insertionSort：

def insertionSort(alist):
    for index in range(1,len(alist)):
        currentvalue=alist[index]
        position=index
        while position>0 and alist[position-1]>currentvalue:
            alist[position]=alist[position-1]
            position=position-1
        alist[position]=currentvalue

在最坏的情况下，插入排序算法的比较次数是前n-1个整数之和，对应的时间复杂度是 $O(n^2)$ 。在最好的情况下（列表已经是有序的），每一轮只需比较一次。

移动操作和交换操作有一个重要的不同点。总体来说，交换操作的处理时间大约是移动操作的3倍，因为后者只需进行一次赋值。在基准测试中，插入排序算法的性能很不错。

四、希尔排序

希尔排序也称“递减增量排序”，它对插入排序做了改进，将列表分成数个子列表，并对每一个列表应用插入排序。如何切分列表是希尔排序的关键——并不是连续切分，而是使用增量i（有时称作步长）选取所有间隔为i的元素组成子列表。

希尔排序函数shellSort：

def shellSort(alist):
    sublistcount=len(alist)//2
    while sublistcount>0:
        for startposition in range(sublistcount):
            gapInsertionSort(alist,startposition,sublistcount)
        print("After increments of size",sublistcount,"The list is",alist)
        sublistcount=sublistcount//2

def gapInsertionSort(alist,start,gap):
    for i in range(start+gap,len(alist),gap):
        currentvalue=alist[i]
        position=i
        while position>=gap and alist[position-gap]>currentvalue:
            alist[position]=alist[position-gap]
            position=position-gap
        alist[position]=currentvalue

if __name__=="__main__":
    alist=[54,26,93,17,77,31,44,55,20]
    print(shellSort(alist))

希尔排序的时间复杂度大概介于 $O(n)$ 和 $O(n^2)$ 之间。希尔排序的时间复杂度可以达到 $O(n^\frac{3}{2})$ 。

五、归并排序

归并排序是递归算法，使用了分治策略，每次将一个列表一分为二，如果列表为空或只有一个元素，那么从定义上来说它就是有序的（基本情况）。如果列表不止一个元素，就将列表一分为二，并对两部分都递归调用并归并排序。当两部分都有序后，就进行归并这一基本操作。归并是指将两个较小的有序列表归并为一个有序列表的过程。

归并排序函数mergeSort：

def mergeSort(alist):
    print("Spiltting ",alist)
    if len(alist)>1:
        mid=len(alist)//2
        lefthalf=alist[:mid]
        rightleft=alist[mid:]

        mergeSort(lefthalf)
        mergeSort(rightleft)

        i=0
        j=0
        k=0
        while i<len(lefthalf) and j<len(rightleft):
            if lefthalf[i]<rightleft[j]:
                alist[k]=lefthalf[i]
                i=i+1
            else:
                alist[k]=rightleft[j]
                j=j+1
            k=k+1

        while i<len(lefthalf):
            alist[k]=lefthalf[i]
            i=i+1
            k=k+1

        while j<len(rightleft):
            alist[k]=rightleft[j]
            j=j+1
            k=k+1
    print("Merging ",alist)

if __name__=="__main__":
    b=[54,26,93,17,77,31,44,55,20]
    print(mergeSort(b))

运行结果如下：

Spiltting  [54, 26, 93, 17, 77, 31, 44, 55, 20]
Spiltting  [54, 26, 93, 17]
Spiltting  [54, 26]
Spiltting  [54]
Merging  [54]
Spiltting  [26]
Merging  [26]
Merging  [26, 54]
Spiltting  [93, 17]
Spiltting  [93]
Merging  [93]
Spiltting  [17]
Merging  [17]
Merging  [17, 93]
Merging  [17, 26, 54, 93]
Spiltting  [77, 31, 44, 55, 20]
Spiltting  [77, 31]
Spiltting  [77]
Merging  [77]
Spiltting  [31]
Merging  [31]
Merging  [31, 77]
Spiltting  [44, 55, 20]
Spiltting  [44]
Merging  [44]
Spiltting  [55, 20]
Spiltting  [55]
Merging  [55]
Spiltting  [20]
Merging  [20]
Merging  [20, 55]
Merging  [20, 44, 55]
Merging  [20, 31, 44, 55, 77]
Merging  [17, 20, 26, 31, 44, 54, 55, 77, 93]
None

归并操作每次从有序列表中取出最小值，放回初始列表。

归并排序算法的时间复杂度是 $O(nlogn)$ 。

六、快速排序

和归并排序一样，快速排序也采用分治策略，但不使用额外的存储空间。不过，代价是列表可能不会被一分为二。出现这种情况，算法的效率会有所下降。

快速排序算法首先选出一个基准值。基准值的作用是帮助切分列表。在最终的有序列表中，基准值的位置通常被称作分割点，算法在分割点切分列表，以继续对快速排序的子调用。

找到基准值后，下一步是分区操作。它会找到分割点，同时将其他元素放到正确的一边——要么大于基准值，要么小于基准值。

分区操作首先找到两个坐标——leftmark和rightmark——它们分别位于列表剩余元素的开头和结尾。分区的目的是根据排序元素与基准值的相对大小将它们放到正确的一边，同时逐渐逼近分割点。

首先加大leftmark，直到遇到一个大于基准值的元素。然后减小rightmark，直到遇到一个小于基准值的元素。这样一来，就找到两个与最终的分割点错序的元素。互换这两个元素，然后重复上述过程。

当rightmark小于leftmark时，过程终止。此时，rightmark的位置就是分割点。将基准值与当前位于分割点的元素互换，即可使基准值位于正确的位置。分割点左边的所有元素都小于基准值，右边的所有元素都大于基准值。因此，可以在分割点处将列表一分为二，并针对左右两部分递归调用快速排序函数。

快速排序函数quickSort：

def quickSort(alist):
    quickSortHelper(alist,0,len(alist)-1)

def quickSortHelper(alist,first,last):
    if first<last:
        splitpoint=partition(alist,first,last)
        quickSortHelper(alist,first,splitpoint-1)
        quickSortHelper(alist,splitpoint+1,last)

def partition(alist,first,last):
    pivotvalue=alist[first]
    leftmark=first+1
    rightmark=last
    done=False
    while not done:
        while leftmark<=rightmark and alist[leftmark]<=pivotvalue:
            leftmark=leftmark+1
        while alist[rightmark]>=pivotvalue and rightmark>=leftmark:
            rightmark=rightmark-1
        if rightmark<leftmark:
            done=True
        else:
            temp=alist[leftmark]
            alist[leftmark]=alist[rightmark]
            alist[rightmark]=temp
    temp=alist[first]
    alist[first]=alist[rightmark]
    alist[rightmark]=temp
    return rightmark

快速排序的时间复杂度是 $O(nlogn)$ 。另外，快速排序算法不需要像归并排序算法那样使用额外的存储空间。