Python内排序

__author__ = 'IanHwang'
#  __coding:utf8__
# 冒泡排序
# 时间复杂度：O(n ^ 2)
# 稳定排序
def BubbleSort(array):
    for i in range(0, len(array)):
        flag = True
        for j in range(i, 0, -1):
            if(array[j] < array[j-1]):
                array[j], array[j-1] = array[j-1], array[j]
                flag = False
            if flag:
                break
    return array

# 选择排序
# 时间复杂度：O(n ^ 2)
# 不稳定排序
def SelectSort(array):
    for i in range(0, len(array)):
        pMin = i
        for j in range(i + 1, len(array)):
            if (array[j] < array[pMin]):
                pMin = j
        if(pMin != i):
            array[pMin], array[i] = array[i], array[pMin]
    return array

# 插入排序
# 时间复杂度：O(n ^ 2)
# 稳定排序
def InsertSort(array):
    for i in range(0, len(array)):
        for j in range(i, 0, -1):
            if(array[j] < array[j-1]):
                array[j], array[j-1] = array[j-1], array[j]
    return array

# 快速排序
# 时间复杂度：好O(n * log(n)),坏O(n ^ 2)
# 不稳定排序
def QuickSort(array):
    quickSort(array, 0, len(array)-1)
    return array

def quickSort(array, left, right):
    if(left < right):
        pivotpos = partition(array, left, right)
        quickSort(array, left, pivotpos -1)
        quickSort(array, pivotpos +1, right)

def partition(array, left, right):
    if(left < right):
        pivotpos = left
        pivot = array[left]
        for i in range(left, right +1):
            if(array[i] < pivot):
                pivotpos += 1
                if(pivotpos != i):
                    array[pivotpos], array[i] = array[i], array[pivotpos]
        array[pivotpos], array[left] = array[left], array[pivotpos]
    return pivotpos

# 希尔排序
# 时间复杂度：O(n * log(n)) ---- O(n ^ 2)
# 不稳定排序
def ShellSort(array):
    delta = int(len(array)/2)
    while(delta > 0):
        for i in range(0, delta):
            for j in range(i + delta,len(array), delta):
                for k in range(j, 0, -1):
                    if(array[k] < array[k - delta]):
                        array[k], array[k - delta] = array[k - delta], array[k]
        delta = int(delta/ 2)
    return array

# 堆排序
# 时间复杂度：O(n * log(n))
# 不稳定排序
def exchange(array,i, j):
    x = array[i]
    array[i]=array[j]
    array[j]=x
def maxHeapify(array,end,i):
    l=2*i+1
    r=2*(i+1)
    max=i
    if l<end and array[i]<array[l]:
        max=l
    if r<end and array[max]<array[r]:
        max=r
    if max <> i:
        exchange(array,i,max)
        maxHeapify(array,end,max)
def buildMaxHeap(array):
    end=array.__len__()
    start=end/2-1
    for i in range(start,-1,-1):
        maxHeapify(array,end,i)
def HeapSort(array):
    end=array.__len__()
    buildMaxHeap(array)
    for i in range(end-1,0,-1):
        exchange(array,i,0)
        maxHeapify(array,i,0)

# 归并排序
# 时间复杂度：O(n * log(n))
# 稳定排序
def MergeSort(arr):
    def marge(start, mid, end):
        leftLength = mid - start + 1
        rightLength = end - mid
        left = [0] * leftLength
        right = [0] * rightLength
        for i in range(0, leftLength):
            left[i] = arr[start + i]
        for j in range(0, rightLength):
            right[j] = arr[mid + j +1]
        i = j = 0
        k = start
        while i < leftLength and j < rightLength:
            if left[i] < right[j]:
                arr[k] = left[i]
                i += 1
            else:
                arr[k] = right[j]
                j += 1
            k += 1
        if i < leftLength:
            for i in range(i, leftLength):
                arr[k] = left[i]
                i += 1
                k += 1
        if j < rightLength:
            for j in range(j, rightLength):
                arr[k] = right[j]
                j += 1
                k += 1
    def sort(start, end):
        if start < end:
            mid = (end + start) // 2
            sort(start, mid)
            sort(mid+1, end)
            marge(start, mid, end)
    sort(0, len(arr)-1)

# 测试函数
arr = [9,8,7,6,5,4,3,2,1]
# BubbleSort(arr)
# SelectSort(arr)
# InsertSort(arr)
# QuickSort(arr)
# ShellSort(arr)
# HeapSort(arr)
# MergeSort(arr)
print(arr)