本文Python实现了插入排序、基数排序、希尔排序、冒泡排序、高速排序、直接选择排序、堆排序、归并排序的后面四种。

上篇：Python学习（三） 八大排序算法的实现（上）

1.高速排序

描写叙述

通过一趟排序将要排序的数据切割成独立的两部分，当中一部分的全部数据都比另外一部分的全部数据都要小，然后再按此方法对这两部分数据分别进行高速排序，整个排序过程能够递归进行，以此达到整个数据变成有序序列。

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．反复上述过程

代码实现

def quick_sort(lists):

    if lists == []:

        return []

    else:

        divide = lists[0]

        lesser = quick_sort([x for x in lists[1:] if x<divide])

       #链表推导式。返回值是由for或if子句之后的表达式得到的元素组成的链表

        bigger = quick_sort([x for x in lists[1:] if x>=divide])

        return lesser + [divide] + bigger

if __name__=="__main__":

    lists = [19,-3,2,10,45,-34,17]

    print quick_sort(lists)

2.直接选择排序

描写叙述

基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换。第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完成。

代码实现

def select_order(lists):

    length = len(lists)

    for i in range(0,length):

        min = i

        for j in range(i+1,length):

            if lists[min] > lists[j]:

                min = j

        lists[min],lists[i] = lists[i],lists[min]

    return lists

if __name__ == '__main__':

    lists = [12,13,15,9,16,14]

    print select_order(lists) 

3.堆排序

描写叙述

堆排序(Heapsort)是指利用堆积树（堆）这样的数据结构所设计的一种排序算法，它是选择排序的一种。能够利用数组的特点高速定位指定索引的元素。堆分为大根堆和小根堆。是全然二叉树。

大根堆的要求是每一个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。

在数组的非降序排序中。须要使用的就是大根堆，由于依据大根堆的要求可知，最大的值一定在堆顶。

利用了大顶堆堆顶元素最大的特点，不断取出最大元素，并调整使剩下的元素还是大顶堆。依次取出最大元素就是排好序的列表。

代码实现

def build_heap(lists):

    count = len(lists)

    for i in range(count//2-1,-1,-1):

        adjust_heap(lists,i,count)

def adjust_heap(lists,i,n):

    j = i*2 +1

    while j < n:

        if j+1 < n and lists[j]<lists[j+1]:

            j +=1

        if lists[i] > lists[j]:

            break

        lists[i],lists[j] = lists[j],lists[i]

        i = j

        j = i*2 + 1

#大顶堆排序

def heap_sort( lists ):

    count = len( lists )

    build_heap( lists )

    #交换堆顶与最后一个结点,再调整堆

    for i in range( count - 1, 0, -1 ):

        lists[0], lists[i] = lists[i], lists[0]

        adjust_heap( lists, 0, i )

    return lists

lists = [-3, 1, 3, 0, 9, 7]

print heap_sort(lists)

4.归并排序

描写叙述

归并排序是建立在归并操作上的一种有效的排序算法,该算法是採用分治法（Divide and Conquer）的一个很典型的应用。

将已有序的子序列合并。得到全然有序的序列；即先使每一个子序列有序。再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并排序详细工作原理例如以下（如果序列共同拥有n个元素）：

1. 将序列每相邻两个数字进行归并操作，形成个序列，排序后每一个序列包括两个元素

2. 将上述序列再次归并，形成个序列。每一个序列包括四个元素

3. 反复步骤2。直到全部元素排序完成

代码实现

def merge_sort(lists):

    if len(lists)<=1:

        return lists

    left = merge_sort(lists[:len(lists)/2])

    right = merge_sort(lists[len(lists)/2:len(lists)])

    result = []

    while len(left) > 0 and len(right)> 0:

        if( left[0] > right[0]):

            result.append(right.pop(0))

        else:

            result.append(left.pop(0))

    if(len(left)>0):

        result.extend(merge_sort(left))

    else:

        result.extend(merge_sort(right))

    return result

def main():

    lists = [2,11,55,33,32,64,18]

    print merge_sort(lists)

if __name__=="__main__":

    main()