用Python实现常见的排序算法

1. 冒泡排序

　　冒泡排序的思路十分简单，交换相邻的两个逆序的元素，知道迭代完所有元素为止。其耗时为O（n^2）

　

array = [9,3,7,4,2,6,5,1,8,0,19,15,13,18,12,16,17,11,14,20]
print 'Before bubble sorting:'
print array

print ''
print 'During bubble sorting:'
for i in range(0,len(array) - 1)://两轮循环迭代数组的所有元素
    for j in range(i + 1,len(array)):
        if array[i] > array[j]://如果当前两个相邻元素的大小关系不符要求，交换之
            array[i],array[j] = array[j],array[i]
            print array

print ''
print 'After bubble sorting:'
print array

2. 插入排序

　　插入排序把当前要排序的数组分为两部分，不妨设为array[1:len],一部分是已经排序好的子数组，设为array[1:k],一段是未排序好的字数组,不妨设为array[k+1:len]。每次从array[k+1:len]中选取array[k+1]作为要插入array[1:k]的元素。确定好位置以后插入即可。

　　插入排序是就地排序，不需要大量的辅助空间。

　

array = [4,2,6,10,7,12,1,8,13,44,5]

print array

for i in range(1,len(array))://从数组的第二个元素开始
    value = array[i]
    j = i-1
    while j >= 0 and array[j] > value://如果array[j]小于当前value，则找到了合适的插入位置，若j《0，则插入位置为第一个元素。
        array[j + 1] = array[j]
        j -= 1
    
    array[j + 1] = value//j有可能小于零

print array

3. 堆排序

　　用数组来表示二叉树。

　　堆是一种二叉树。

def maxHeapify(array,current,length):
    left = 2 * current + 1
    right = (current + 1) * 2
    largest = current

    if(left < length and array[current] < array[left]):
        largest = left
    
    if(right < length and array[largest] < array[right]):
        largest = right

    if largest != current:
        array[current],array[largest] = array[largest],array[current]
        maxHeapify(array,largest,length)

def buildMaxHeap(array,length):
    for i in range(length/2-1,-1,-1):
        maxHeapify(array,i,length)
    print array

def HeapSort(array):
    buildMaxHeap(array,len(array))
    
    for i in range(len(array)-1,0,-1):
        array[i],array[0] = array[0],array[i]
        maxHeapify(array,0,i)

array = [4,2,6,10,7,12,1,8,13,44,5]
print array
HeapSort(array)
print array

 

4. 合并排序

　　合并排序体现了分治递归的思想。

　　将待排序的数组分为两个子数组排序，再将排序好的子数组合并为一个数组。对于子数组的排序也如法炮制。递归的边界条件是待排序的数组是否只剩下一个元素。排序的主要过程其实在合并的过程当中。从单个元素开始排序，自底向上。

def merge(array,left,middle,right)://二路归并排序
    length = right -left + 1
    temp = [0 for i in range(0,length)]//合并排序需要与排序数组大小相等的辅助空间
    i = left
    j = middle + 1
    k = 0

    while i <= middle and j <= right:
        if array[i] <= array[j]:
            temp[k] = array[i]
            i += 1
            k += 1
        else :
            temp[k] = array[j]
            j += 1
            k += 1

    if i <= middle:
        temp[k:length] = array [i:middle + 1]
    elif j <= right:
        temp[k:length] = array [j:right + 1]

    array[left:right + 1] = temp[0:length]    

def mergeSort(array,left,right)://本函数比较好理解
    if left < right:
        middle = (left + right) / 2
        mergeSort(array,left,middle)
        mergeSort(array,middle+1,right)
        merge(array,left,middle,right)

array = [4,2,10,9,7,8,14,1,25,98,45,17,43,86,56,19,20]
print array
mergeSort(array,0,len(array)-1)
print array