（这里默认排序是从小到大）
关于每种排序的视频讲解，参见普林斯顿的算法课

选择排序 selection sort

每次选择最小的放到左边

# 选择排序 selection sort
def Selection_sort(a):
    n = len(a)
    for i in range(n):
        Min = i
        for j in range(i,n):
            if a[j]<a[Min]:
                Min=j
        t=a[i]
        a[i] = a[Min]
        a[Min] = t
    return a

插入排序 insertion sort

依次插入到之前合适的位置

# 插入排序 insertion sort
def Insertion_sort(a):
    n = len(a)
    for i in range(1,n):
        j = i
        while j >= 0 and a[j] < a[j-1]:
            t = a[j]
            a[j] = a[j-1]
            a[j-1] = t
            j = j-1
    return a

希尔排序 Shellsort

跨步排序，步长逐渐缩小

# 希尔排序 Shellsort
def Shellsort(a):
    n = len(a)
    h = 1
    while h < n/3:
        h=int(3 * h + 1)
    while h >= 1:
        i = 0
        while i+h < n:
            j=i+h
            while (j-h >= 0) & (a[j] < a[j-h]):
                t = a[j]
                a[j] = a[j-h]
                a[j-h] = t
                j = j-h
            i=i+1
        h = int(h/3)
    return a

归并排序 Mergesort

对半递归排序，再合并

# 归并排序 Mergesort
def Mergesort(a):
    msort(a,0,len(a)-1)
    return a

def msort(a,lo,hi):
    if lo == hi:
        return a[lo]
    else:
        mid = lo + int((hi - lo)/2)
        msort(a, lo, mid)
        msort(a, mid+1, hi)
        merge(a, lo, mid ,hi)

def merge(a,lo,mid,hi):
    aux = len(a)*[0]
    i = lo
    j = mid+1
    for k in range(lo,hi+1):
        aux[k] = a[k]
    for k in range(lo,hi+1):
        if i > mid:
            a[k] = aux[j]
            j = j+1
        elif j > hi:
            a[k] = aux[i]
            i = i+1
        elif aux[i] > aux[j]:
            a[k] = aux[j]
            j=j+1
        else:
            a[k] = aux[i]
            i=i+1   
    return a

快速排序 Quicksort

利用划分元素

# 快速排序 Quicksort
import random
def Quicksort(a):
    random.shuffle(a)
    qsort(a,0,len(a)-1)
    return a

def qsort(a,lo,hi):
    if hi <= lo:
        return
    j = partition(a,lo,hi)
    qsort(a,lo,j-1)
    qsort(a,j+1,hi)    

def partition(a,lo,hi):
    i = lo
    j = hi+1
    v = a[lo]
    while True:
        i = i+1
        while a[i] < v:
            i = i+1
            if i == hi:
                break
        j = j-1
        while v < a[j]:
            j = j-1
            if j == lo:
                break
        if i >= j:
            break
        t = a[i]
        a[i] = a[j]
        a[j] = t
    t = a[j]
    a[j] = a[lo]
    a[lo] = t
    return j

总结