算法-排序（一）

排序是计算机科学中的一个重要的研究领域。

分析算法时需要考虑比较大小及交换次数。

冒泡排序

"""
多次遍历列表。比较相邻元素，将不合顺序的交换。每一轮遍历都将下一个最大值放到正确的位置上。
通常被认为是效率最低的排序算法，因为在确定最终的位置前必须交换元素。多余的交换操作代价很大。

由于冒泡排序要遍历列表中未排序的部分，因此它具有其他排序算法没有的用途。
特别是，如果在一轮遍历中没有发生元素交换，就可以确定列表已经有序。

可以修改冒泡排序函数，使其在遇到这种情况时提前终止。对于只需要遍历几次的列表，冒泡排序可能有优势，
因为它能判断出有序列表并终止排序过程。这种排序通常被称作短冒泡。
"""

def bubbleSort(alist):
    for passnum in range(len(alist)-1, 0 , -1):
        for i in range(passnum):
            if alist[i] > alist[i+1]:
                # Python 允许同时赋值，所以可以一条语句完成交换操作。
                alist[i], alist[i+1] = alist[i+1], alist[i]

alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(alist)
bubbleSort(alist)
print(alist)

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

 选择排序

"""
在冒泡排序上做了改进，每次遍历只交换一次。
即在每次遍历时寻找最大值，并在遍历完之后放到正确的位置上。
时间复杂度O(n²），因为减少了交换次数，通常比冒泡排序更快。
"""
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
        alist[fillslot], alist[positionOfMax] = alist[positionOfMax], alist[fillslot]

alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(alist)
selectionSort(alist)
print(alist)

插入排序

"""
时间复杂度O(n²)。
在列表较低的一端维护一个有序的子列表，并逐个将每个新元素插入这个子列表。

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


alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(alist)
insertionSort(alist)
print(alist)

希尔排序

"""
希尔排序也称递减增量排序，它对插入排序做了改进，将列表分成数个子列表，并对每一个子列表应用插入排序。
如何切分列表是希尔排序的关键：
    并不是连续切分，而是使用增量i(有时称作步长)选取所有间隔为i的元素组成子列表。
？？？
时间复杂度介于O(n)和O(n²)之间，如下的代码时间复杂度O(n²)
调整增量，...
"""
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