各种排序算法的Python实现

最近刚刚接触Python，Python语法简洁清晰，具有很好的易读性，编写的算法可以很容易的看出其本质。故而用Python编写算法，既可以熟悉算法，又可以练习Python，何乐而不为呢？

插入排序

def InsertSort (lists):
    for i in range(0, len(lists) - 1):
        for j in range(i + 1, 0, -1):
            if lists[j] < lists[i]:
                lists[i], lists[j] = lists[j], lists[i]
            else:
                break

选择排序

def SelectionSort (lists):
    for i in range(0, len(lists)):
        min_number = i
        for j in range(i + 1, len(lists)):
            if lists[j] < lists[min_number]:
                min_number = j
        lists[i], lists[min_number] = lists[min_number], lists[i]# swap

归并排序

def MergeSort (lists):
    if len(lists) <= 1:
        return lists
    num = int( len(lists)/2 )
    return Merge(MergeSort(lists[:num]),
                 MergeSort(lists[num:]))

def Merge (left, right):
    r, l = 0, 0
    result = []
    while l < len(left) and  r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += right[r:]
    result += left[l:]
    return result

快速排序

def QuickSort(lists, p, r):
    if (p < r):
        q = Partition(lists, p, r)
        QuickSort(lists, p, q - 1)
        QuickSort(lists, q + 1, r)

def Partition(lists, p, r):
    x = lists[r]
    i = p - 1
    for j in range(p, r):
        if (lists[j] <= x):
            i += 1
            lists[i], lists[j] = lists[j], lists[i]
    lists[i + 1], lists[r] = lists[r], lists[i + 1]
    return i + 1

堆排序

def HeapSort(lists):
    BuildMaxHeap(lists)
    for i in range(len(lists) - 1, 0, -1):
        lists[0], lists[i] = lists[i], lists[0]
        MaxHeapify(lists, 0, i)

def BuildMaxHeap(lists):
    for i in range((int)(len(lists) / 2) - 1, -1, -1):
        MaxHeapify(lists, i, len(lists))

def MaxHeapify(lists, i, heap_size):
    if 2 * i + 1 < heap_size and lists[2 * i + 1] > lists[i]:
        largest = 2 * i + 1
    else:
        largest = i
    if 2 * i + 2 < heap_size and lists[2 * i + 2] > lists[largest]:
        largest = 2 * i + 2
    if largest != i:
        lists[i], lists[largest] = lists[largest], lists[i]
        MaxHeapify(lists, largest, heap_size)