八大排序python实现

最新推荐文章于 2024-11-04 21:51:40 发布

weixin_34362991

最新推荐文章于 2024-11-04 21:51:40 发布

阅读量89

点赞数

文章标签： python 数据结构与算法

原文链接：http://www.cnblogs.com/lrheisoo/p/7142184.html

版权

1.直接插入排序：将需要排序的列表分为已排序和未排序部分，依次将未排序部分的数字与已排序部分进行比较，找到比自己小的数字时停止，并插入到该数字后一位

def insertSort(L):
    lenth = len(L)
    for i in range(1, lenth):
            if L[i] < L[i-1]:
                j = i-1
                tmp = L.pop(i)
                while tmp < L[j]:
                        j = j-1
                L.insert(j+1, tmp)
    return L

2.希尔排序：

第一次排序：gap = 5（10/2），相距5的数字为一组，一共分为五组，分别进行插入排序

第二次排序：gap = 2（5/2），相距为2的数字为一组，一共分为2组，分别进行插入排序

第三次排序：gap = 1（2/1），只有一组，进行插入排序后，得到最后答案

def shellSort(L):
    lenth = len(L)
    gap = lenth/2
    while gap >= 1:
        for i in range(gap, lenth):
            while i >= gap and L[i-gap] > L[i]:
                L[i], L[i-gap] = L[i-gap], L[i]
                i = i-gap
        gap = gap/2
    return L

3.选择排序-简单选择排序

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

#! coding: utf-8
def selectSort(L):
    lenth = len(L)
    for i in range(lenth - 1):
        mx_idx = i
        for k in range(i, lenth):
            if L[k] > L[mx_idx]:
                mx_idx = k
        L[i], L[mx_idx] = L[mx_idx], L[i]
    return L

if __name__=="__main__":
    L = [3,1,5,7,2,4,9,6]
    print selectSort(L)

优化：双向选择，同时选择最大值和最小值，循环少一半

#! coding: utf-8
def selectSort(L):
    lenth = len(L)
    for i in range((lenth - 1)/2):
        #import pdb;pdb.set_trace()
        mx_idx = i
        mn_idx = i
        for k in range(i, lenth - i):
            if L[k] > L[mx_idx]:
                mx_idx = k
            if L[k] < L[mn_idx]:
                mn_idx = k
        #import pdb;pdb.set_trace()
        L[i], L[mx_idx] = L[mx_idx], L[i]
        L[lenth - i -1], L[mn_idx] = L[mn_idx], L[lenth - i - 1]
    return L

if __name__=="__main__":
    L = [3,1,5,7,2,4,9,6]
    print selectSort(L)

4.堆排序

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

(b) 小顶堆序列：（12，36，24，85，47，30，53，91）

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法（2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法（2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）

算法的实现：

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

#! coding: utf-8
def heapParse(L, s, lenth):
    import pdb;pdb.set_trace()
    tmp = L[s]
    child = s * 2 + 1
    while child < lenth:
        if child + 1 < lenth and L[child] < L[child + 1]:
            child += 1
        if L[s] < L[child]:
            L[s] = L[child]
            s = child
            child = s * 2 + 1
        else:
            break
        L[s] = tmp
    print "%s: %s" % (lenth, L)

def heapBuild(L, lenth):
    for i in range((lenth - 1)/2, -1, -1):
        heapParse(L, i, lenth)

def heapSort(L, lenth):
    heapBuild(L, lenth)
    for x in range(lenth - 1, 0, -1):
        L[0], L[x] = L[x], L[0]
        heapParse(L, 0, x)

if __name__ == "__main__":
    L = [3,1,5,7,2,4,9,6,10,8]
    heapSort(L, len(L))
    print L