排序算法汇总的有经常用到的冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序七种，代码可以直接测试。
代码如下：

#!/usr/bin/python
# coding: utf-8

myarr = [12,32,2,56,43,33,67,99,42,55,65,37,90]
# 输出排序前的列表
print("排序前")
print(myarr)

############ 冒泡
lenth=len(myarr)
for i in range(lenth):
    for j in range(lenth-i-1):
        if myarr[j] > myarr[j + 1]:
            myarr[j], myarr[j + 1] = myarr[j + 1], myarr[j]

############ 选择排序
lenth = len(myarr)
for i in range(lenth):
    minIndex = i
    for j in range(i+1, lenth):
        if myarr[j] < myarr[minIndex]:
            minIndex = j
    myarr[i], myarr[minIndex] = myarr[minIndex], myarr[i]

############# 插入排序
lenth = len(myarr)
for i in range(1,lenth):
    preIndex = i
    while preIndex > 0 and myarr[preIndex-1] > myarr[preIndex]:
        myarr[preIndex - 1], myarr[preIndex] = myarr[preIndex], myarr[preIndex - 1]
        preIndex -= 1

############# 希尔排序
def ShellInsetSort(array, len_array, dk):  # 直接插入排序
    for i in range(dk,len_array):
        preIndex = i
        while preIndex > 0 and myarr[preIndex-dk] > myarr[preIndex]:
            myarr[preIndex - dk], myarr[preIndex] = myarr[preIndex], myarr[preIndex - dk]
            preIndex -= dk
    return array


lenth = len(myarr)
dk = int(lenth/2)  # 增量
while(dk >= 1):
    myarr = ShellInsetSort(myarr, lenth, dk)
    print(">>:",myarr)
    dk = int(dk/2)

########### 归并排序
def merge_sort(lst):
    if len(lst) <= 1:
        return lst          # 从递归中返回长度为1的序列

    middle = len(lst) / 2
    left = merge_sort(lst[:middle])     # 通过不断递归，将原始序列拆分成n个小序列
    right = merge_sort(lst[middle:])
    return merge(left, right)

def merge(left, right):
    i, j = 0, 0
    result = []
    while i < len(left) and j < len(right):  # 比较传入的两个子序列，对两个子序列进行排序
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])         # 将排好序的子序列合并
    result.extend(right[j:])
    return result

myarr = merge_sort(myarr)

########### 快速排序
def QuickSort(arr, firstIndex, lastIndex):
    if firstIndex < lastIndex:
        divIndex = Partition(arr, firstIndex, lastIndex)

        QuickSort(arr, firstIndex, divIndex)
        QuickSort(arr, divIndex + 1, lastIndex)
    else:
        return


def Partition(arr, firstIndex, lastIndex):
    i = firstIndex - 1
    for j in range(firstIndex, lastIndex):
        if arr[j] <= arr[lastIndex]:
            i = i + 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[lastIndex] = arr[lastIndex], arr[i + 1]
    return i

QuickSort(myarr,0,len(myarr)-1)

########### 堆排序
def MAX_Heapify(heap,HeapSize,root):#在堆中做结构调整使得父节点的值大于子节点
    left = 2 * root + 1
    right = left + 1
    larger = root
    if left < HeapSize and heap[larger] < heap[left]:
        larger = left
    if right < HeapSize and heap[larger] < heap[right]:
        larger = right
    if larger != root:  # 如果做了堆调整则larger的值等于左节点或者右节点的，这个时候做对调值操作
        heap[larger], heap[root] = heap[root], heap[larger]
        MAX_Heapify(heap, HeapSize, larger)

def Build_MAX_Heap(heap):  # 构造一个堆，将堆中所有数据重新排序
    HeapSize = len(heap) # 将堆的长度当独拿出来方便
    for i in xrange((HeapSize - 2) // 2, -1, -1):  # 从后往前出数
        MAX_Heapify(heap, HeapSize, i)

def HeapSort(heap): # 将根节点取出与最后一位做对调，对前面len-1个节点继续进行对调整过程。
    Build_MAX_Heap(heap)
    for i in range(len(heap) - 1, -1, -1):
        heap[0], heap[i] = heap[i], heap[0]
        MAX_Heapify(heap, i, 0)
    return heap

myarr = HeapSort(myarr)

# 输出排序后的列表
print("排序后")
print(myarr)
复制

注意：在测试某排序算法时，请将其他算法注释掉。