编程语言
首页 > 编程语言> > 排序算法

排序算法

作者:互联网

参考资源:https://blog.csdn.net/weixin_41190227/article/details/86600821

参考资源:https://www.cnblogs.com/Glory-D/p/7884525.html

 

总的来说,排序算法共有十大类,即冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、计数排序,桶排序,基数排序。如下图所示,十种排序算法比较。

图片名词解释:

[1]. 冒泡排序(Bubble Sort)

  冒泡排序 是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

 

  1.1 算法描述

 

  1.2 动图演示
          

 

  1.3 算法分析

 

1.4 代码实现

def bubblesort(alist):
    """冒泡排序"""
    n = len(alist)
    for k in range(n-1):
        count = 0
        for i in range(n-1 - k):
            if alist[i] > alist[i+1]:
                alist[i], alist[i + 1] = alist[i + 1], alist[i]
                count +=1
        if count == 0:
            return alist
    return alist


if __name__ == '__main__': # 测试
    a = [40, 5, 8, 6, 1, 3, 5, 2, 6, 4, 8, 9, 10]
    s = bubblesort(a)
    print(s)

 

 

[2].  选择排序(Select Sort)

  选择排序 是表现最稳定的排序算法之一 ,因为无论什么数据进去都是O(n2)的时间复杂度 ,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

    选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

 

  2.1 算法描述

    n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下:


  2.2 动图演示

 

  2.3 代码实现

def selectsort(slist):
    """选择排序,序列的数据类型为list"""
    n = len(slist)
    for i in range(n - 2):
        flag = i
        for k in range(i + 1, n):
            if slist[flag] > slist[k]:
                flag = k
        slist[i], slist[flag] = slist[flag], slist[i]
    return slist


if __name__ == '__main__':    # 测试
    a = [4, 5, 8, 9, 54, 6, 74, 6, 4, 5, 6, 4, 5, 4]
    s = selectsort(a)
    print(s)

  2.4 算法分析

 

 

[3] 插入排序(Insert Sort)

   插入排序(Insertion-Sort) 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

 

  3.1 算法描述

    一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

 

  3.2 动图演示

  3.3 代码实现

def insertsort(ilist):
    """插入排序算法,序列的数据格式为list"""
    n = len(ilist)
    for i in range(1, n):
        for k in range(i, 0, -1):
            if ilist[k] < ilist[k - 1]:
                ilist[k], ilist[k - 1] = ilist[k - 1], ilist[k]
            else:
                break
    return ilist


if __name__ == '__main__':     # 测试
    a = [4, 1, 5, 2, 3, 6, 9, 8, 4, 1, 5, 6]
    s = insertsort(a)
    print(s)

 

  3.4 算法分析

 

[4]. 希尔排序

    希尔排序是希尔(Donald Shell) 于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

    希尔排序是把记录按下表的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

 

  4.1 算法描述

    我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2…1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

    先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:


  4.2 过程演示

 

4.3 代码实现

def shellsort(slist):
    """希尔排序算法,序列的数据格式为list"""
    n = len(slist)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            for k in range(i, gap-1, -1):
                if slist[k] < slist[k - gap]:
                    slist[k], slist[k - gap] = slist[k - gap], slist[k]
                else:
                    break
        gap = gap // 2
    return slist


if __name__ == '__main__':  # 测试
    a = [4, 1, 5, 2, 3, 6, 9, 8, 4, 1, 5, 6, 1, 5, 2, 3, 6, 9, 8, 4,]
    s = shellsort(a)
    print(s)

 

  4.4 算法分析

 

 

[5]. 归并排序(Merge Sort)

和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。

    归并排序 是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。

 

  5.1 算法描述


  5.2 动图演示

 

 

  5.3 代码实现

        [暂为空]

  5.4 算法分析

 

[6]. 快速排序(Quick Sort)

  快速排序 的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。

  6.1 算法描述

      快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:

 

  6.2 动图演示


  6.3 代码实现

def quicksort(qlist, a, b):
    """快速排序"""

    # 递归的退出条件
    if a >= b:
        return

    low = a
    mid = qlist[a]
    high = b
    while low < high:
        if qlist[low] <= mid:
            low += 1
        if qlist[high] > mid:
            high -= 1
        if qlist[low] > mid >= qlist[high]:
            qlist[low], qlist[high] = qlist[high], qlist[low]
            low += 1
            high -= 1

    if qlist[low] > mid:
        qlist[low - 1], qlist[a] = qlist[a], qlist[low - 1]
        low -= 1
    else:
        qlist[low], qlist[a] = qlist[a], qlist[low]

    # 对基准元素左边的子序列进行快速排序
    quicksort(qlist, a, low - 1)

    # 对基准元素右边的子序列进行快速排序
    quicksort(qlist, low + 1, b)


if __name__ == '__main__':  # 测试
    a = [1, 5, 7, 8, 4, 56, 9, 74, 56, 96, 8, 56, 1, 5, 7, 8, 4, 56, 9, 74, 56]
    quicksort(a, 0, len(a) - 1)
    print(a)

  

  6.4 算法分析

 

。。。。。。待续

标签:__,步骤,算法,序列,排序,qlist
来源: https://www.cnblogs.com/carreyBlog/p/12088530.html