排序

总结：

• 插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。反而在这种情况下，快速排序反而慢了。
• 当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
• 若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
• 当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
• 当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下宜用归并排序。
• 当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。

堆排序

def heapsort(l):
    l_len = len(l) - 1
    adjust_node = int(len(l)/2)
    
    for i in range(adjust_node):
        heapadjust(l, adjust_node-i, l_len)
        
    for j in range(len(l)-1):
        l[1], l[l_len-j] = l[l_len-j], l[1]
        heapadjust(l, 1, l_len-j-1)
        
    return [l[i] for i in range(1, len(l))]
def heapadjust(l, start, end):
    tmp = l[start]
    
    i = start
    j = 2 * i
    
    while j <= end:
        if j < end and l[j] < l[j+1]:
            j = j + 1
        if tmp < l[j]:
            l[i] = l[j]
            i = j
            j = 2 * i
        else:
            break
    l[i] = tmp
    
    
L = [50, 16, 30, 10, 60,  90,  2, 80, 70]
L.insert(0, 0)
print(heapsort(L))

归并排序

def mergesort(l):
    if len(l) <= 1:
        return l
    middle = int(len(l)/2)
    left = mergesort(l[:middle])
    right = mergesort(l[middle:])
    return merge_(left, right)
def merge_(a, b):
    c = []
    i = j = 0
    while i < len(a) and j < len(b):
        if int(a[i]) < int(b[j]):
            c.append(a[i])
            i = i + 1
        else:
            c.append(b[j])
            j = j + 1
    if i == len(a):
        for m in b[j:]:
            c.append(m)
    if j == len(b):
        for n in a[i:]:
            c.append(n)
    return c
        
L = [50, 16, 30, 10, 60,  90,  2, 80, 70]
print(mergesort(L))

冒泡排序

原理:每一趟只能将一个数归位,如果有n个数进行排序,只需将n-1个数归位,也就是说要进行n-1趟,所以时间复杂度为O(n²).

def bubblesort(l):
    for i in range(len(l)):
        for j in range(len(l)-1):
            if l[j] > l[j+1]:
                l[j], l[j+1] = l[j+1], l[j]
    return l
l = [50, 16, 30, 10, 60,  90,  2, 80, 70]
print(bubblesort(l))

快速排序

def quicksort(l, low, high):
    i = low
    j = high
    # 递归结束条件
    if i >= j:
        return l
    # 定义key值
    key = l[i]
        # 找到比key小的值，必须从后面开始
    while i < j:
        while i < j and key <= l[j]:
            j = j - 1
        l[i] = l[j]
        while i < j and key > l[i]:
            i = i + 1
        l[j] = l[i]
    # 找到key的位置
    l[i] = key
        # 递归
    quicksort(l, low, i-1)
    quicksort(l, j+1, high)
    return l

l = [50, 16, 30, 10, 60,  90,  2, 80, 70]
print(quicksort(l, 0, len(l)-1))

插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

def insertsort(l):
    for i in range(1, len(l)):
        x = l[i]
        for j in range(i, -1, -1):
            if x < l[j-1]:
                l[j] = l[j-1]
            else:
                break
        l[j] = x
    return l


l = [50, 16, 30, 10, 60,  90,  2, 80, 70]
print(insertsort(l))

希尔排序

# 插入排序的变体
def shellsort(l):
    step = int(len(l)/2)
    for i in range(step, len(l)):
        x = l[i]
        for j in range(i, -1, -step):
            if l[j] < l[j-step]:
                l[j] = l[j-step]
            else:
                break
        l[j] = x
    return l


l = [50, 16, 30, 10, 60,  90,  2, 80, 70]
print(shellsort(l))

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

 def selectsort(l):
    for i in range(len(l)-1):
        index_min = i
        for j in range(i+1, len(l)):
            if l[j] < l[index_min]:
                index_min = j
        l[i], l[index_min] = l[index_min], l[i]
    return l
        
l = [50, 16, 30, 10, 60,  90,  2, 80, 70]
print(selectsort(l))