资讯专栏INFORMATION COLUMN

基本排序算法的Python实现

zhangqh / 1493人阅读

摘要:本篇主要实现九八大排序算法,分别是冒泡排序,插入排序,选择排序,希尔排序,归并排序,快速排序,堆排序计数排序。希尔排序是非稳定排序算法。归并排序算法依赖归并操作。但是,计数排序可以用在基数排序算法中,能够更有效的排序数据范围很大的数组。

本篇主要实现九(八)大排序算法,分别是冒泡排序,插入排序,选择排序,希尔排序,归并排序,快速排序,堆排序,计数排序。希望大家回顾知识的时候也能从我的这篇文章得到帮助。

为了防止误导读者,本文所有概念性内容均截取自对应Wiki

冒泡排序 原理

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

步骤

冒泡排序算法的运作如下:

比较相邻的元素。如果第一个比第二个大,就交换他们两个。

对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

针对所有的元素重复以上的步骤,除了最后一个。

持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

代码

</>复制代码

  1. def bubble_sort(list):
  2. length = len(list)
  3. # 第一级遍历
  4. for index in range(length):
  5. # 第二级遍历
  6. for j in range(1, length - index):
  7. if list[j - 1] > list[j]:
  8. # 交换两者数据,这里没用temp是因为python 特性元组。
  9. list[j - 1], list[j] = list[j], list[j - 1]
  10. return list

这种排序其实还可以稍微优化一下,添加一个标记,在排序已完成时,停止排序。

</>复制代码

  1. def bubble_sort_flag(list):
  2. length = len(list)
  3. for index in range(length):
  4. # 标志位
  5. flag = True
  6. for j in range(1, length - index):
  7. if list[j - 1] > list[j]:
  8. list[j - 1], list[j] = list[j], list[j - 1]
  9. flag = False
  10. if flag:
  11. # 没有发生交换,直接返回list
  12. return list
  13. return list
选择排序 原理

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理大致是将后面的元素最小元素一个个取出然后按顺序放置。

步骤

在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,

再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

重复第二步,直到所有元素均排序完毕。

代码

</>复制代码

  1. def selection_sort(list):
  2. n=len(list)
  3. for i in range (0,n):
  4. min = i
  5. for j in range(i+1,n):
  6. if list[j]
  7. 插入排序
  8. 原理
  9. 插入排序(Insertion Sort)是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

  10. 步骤
  11. 从第一个元素开始,该元素可以认为已经被排序

  12. 取出下一个元素,在已经排序的元素序列中从后向前扫描

  13. 如果该元素(已排序)大于新元素,将该元素移到下一位置

  14. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置

  15. 将新元素插入到该位置后

  16. 重复步骤2~5

  17. 代码
  18. </>复制代码

    1. def insert_sort(list):
    2. n = len(list)
    3. for i in range(1, n):
    4. # 后一个元素和前一个元素比较
    5. # 如果比前一个小
    6. if list[i] < list[i - 1]:
    7. # 将这个数取出
    8. temp = list[i]
    9. # 保存下标
    10. index = i
    11. # 从后往前依次比较每个元素
    12. for j in range(i - 1, -1, -1):
    13. # 和比取出元素大的元素交换
    14. if list[j] > temp:
    15. list[j + 1] = list[j]
    16. index = j
    17. else:
    18. break
    19. # 插入元素
    20. list[index] = temp
    21. return list
  19. 希尔排序
  20. 原理
  21. 希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
    希尔排序是基于插入排序的以下两点性质而提出改进方法的:
    插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率
    但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。

  22. 步骤
  23. 每次以一定步长(就是跳过等距的数)进行排序,直至步长为1.

  24. 代码
  25. </>复制代码

    1. def shell_sort(list):
    2. n = len(list)
    3. # 初始步长
    4. gap = round(n / 2)
    5. while gap > 0:
    6. for i in range(gap, n):
    7. # 每个步长进行插入排序
    8. temp = list[i]
    9. j = i
    10. # 插入排序
    11. while j >= gap and list[j - gap] > temp:
    12. list[j] = list[j - gap]
    13. j -= gap
    14. list[j] = temp
    15. # 得到新的步长
    16. gap = round(gap / 2)
    17. return list
  26. </>复制代码

    1. 步长使用的是Donald Shell的建议,另外步长还可以使用Sedgewick提出的(1, 5, 19, 41, 109,...)。
      也可以使用斐波那契数列除去0和1将剩余的数以黄金分区比的两倍的幂进行运算得到的数列。
  27. 归并排序
  28. 原理
  29. 归并操作(归并算法),指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

  30. 步骤
  31. 迭代法
  32. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列

  33. 设定两个指针,最初位置分别为两个已经排序序列的起始位置

  34. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置

  35. 重复步骤3直到某一指针到达序列尾

  36. 将另一序列剩下的所有元素直接复制到合并序列尾

  37. 递归法
  38. 假设序列共有n个元素:

  39. 将序列每相邻两个数字进行归并操作,形成 {displaystyle floor(n/2)} floor(n/2)个序列,排序后每个序列包含两个元素

  40. 将上述序列再次归并,形成 {displaystyle floor(n/4)} floor(n/4)个序列,每个序列包含四个元素

  41. 重复步骤2,直到所有元素排序完毕

  42. 代码
  43. </>复制代码

    1. # 递归法
    2. def merge_sort(list):
    3. # 认为长度不大于1的数列是有序的
    4. if len(list) <= 1:
    5. return list
    6. # 二分列表
    7. middle = len(list) // 2
    8. left = merge_sort(list[:middle])
    9. right = merge_sort(list[middle:])
    10. # 最后一次合并
    11. return merge(left, right)
    12. # 合并
    13. def merge(left, right):
    14. l,r=0,0
    15. result=[]
    16. while l
    17. 鄙人不才,不知归并排序的迭代法如何用Python实现,望指教。

    18. 快速排序
    19. 原理
    20. 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。

    21. 步骤
    22. 从数列中挑出一个元素,称为"基准"(pivot),

    23. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。

    24. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

    25. 代码
    26. 普通版

    27. </>复制代码

      1. def quick_sort(list):
      2. less = []
      3. pivotList = []
      4. more = []
      5. # 递归出口
      6. if len(list) <= 1:
      7. return list
      8. else:
      9. # 将第一个值做为基准
      10. pivot = list[0]
      11. for i in list:
      12. # 将比急转小的值放到less数列
      13. if i < pivot:
      14. less.append(i)
      15. # 将比基准打的值放到more数列
      16. elif i > pivot:
      17. more.append(i)
      18. # 将和基准相同的值保存在基准数列
      19. else:
      20. pivotList.append(i)
      21. # 对less数列和more数列继续进行排序
      22. less = quick_sort(less)
      23. more = quick_sort(more)
      24. return less + pivotList + more
    28. 咳咳,下面这段代码出自《Python cookbook 第二版》传说中的三行实现python快速排序。

    29. </>复制代码

      1. def qsort(arr):
      2. if len(arr) <= 1:
      3. return arr
      4. else:
      5. pivot = arr[0]
      6. return qsort([x for x in arr[1:] if x < pivot]) +
      7. [pivot] +
      8. qsort([x for x in arr[1:] if x >= pivot])
    30. 当然还有一行语法糖版本:

    31. </>复制代码

      1. qs = lambda xs : ( (len(xs) <= 1 and [xs]) or [ qs( [x for x in xs[1:] if x < xs[0]] ) + [xs[0]] + qs( [x for x in xs[1:] if x >= xs[0]] ) ] )[0]
    32. 是不是感受到了Python的魅力?

    33. 堆排序
    34. 原理
    35. 堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。

    36. 步骤
    37. 创建最大堆:将堆所有数据重新排序,使其成为最大堆

    38. 最大堆调整:作用是保持最大堆的性质,是创建最大堆的核心子程序

    39. 堆排序:移除位在第一个数据的根节点,并做最大堆调整的递归运算

    40. 代码
    41. </>复制代码

      1. def heap_sort(list):
      2. # 创建最大堆
      3. for start in range((len(list) - 2) // 2, -1, -1):
      4. sift_down(list, start, len(list) - 1)
      5. # 堆排序
      6. for end in range(len(list) - 1, 0, -1):
      7. list[0], list[end] = list[end], list[0]
      8. sift_down(list, 0, end - 1)
      9. return list
      10. # 最大堆调整
      11. def sift_down(lst, start, end):
      12. root = start
      13. while True:
      14. child = 2 * root + 1
      15. if child > end:
      16. break
      17. if child + 1 <= end and lst[child] < lst[child + 1]:
      18. child += 1
      19. if lst[root] < lst[child]:
      20. lst[root], lst[child] = lst[child], lst[root]
      21. root = child
      22. else:
      23. break
    42. 计数排序
    43. 原理
    44. 当输入的元素是n个0到k之间的整数时,它的运行时间是Θ(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。

    45. 由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。例如:计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名。但是,计数排序可以用在基数排序算法中,能够更有效的排序数据范围很大的数组。

    46. 步骤
    47. 找出待排序的数组中最大和最小的元素

    48. 统计数组中每个值为i的元素出现的次数,存入数组 C 的第 i 项

    49. 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)

    50. 反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1

    51. 代码
    52. </>复制代码

      1. def count_sort(list):
      2. min = 2147483647
      3. max = 0
      4. # 取得最大值和最小值
      5. for x in list:
      6. if x < min:
      7. min = x
      8. if x > max:
      9. max = x
      10. # 创建数组C
      11. count = [0] * (max - min +1)
      12. for index in list:
      13. count[index - min] += 1
      14. index = 0
      15. # 填值
      16. for a in range(max - min+1):
      17. for c in range(count[a]):
      18. list[index] = a + min
      19. index += 1
      20. return list
    53. 第九种排序
    54. None
      当然不会
      自然就是系统自带的

    55. </>复制代码

      1. list.sort()
    56. 以上所有源代码均在Github共享希望与大家共同进步!

    57. 参考资料
    58. 维基百科: 冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序

    59. Python Cookbook

    60. 感谢
    61. 知乎用户:dhx1793516813、左鸢、灵剑
      为本文缺漏之处提出建议

    62. EOF

    63. </>复制代码

      1. 转载请注明出处:http://eindex.me/post/base-so...
        访问原文「基本排序算法的Python实现」获取最佳阅读体验并参与讨论

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/38112.html

相关文章

  • python-八大算法

    摘要:排序算法总结排序算法平均时间复杂度冒泡排序选择排序插入排序希尔排序快速排序归并排序堆排序基数排序一冒泡排序基本思想两个数比较大小,较大的数下沉,较小的数冒起来。 排序算法总结 排序算法 平均时间复杂度 冒泡排序O(n2) 选择排序O(n2) 插入排序O(n2) 希尔排序O(n1.5) 快速排序O(N*logN) 归并排序O(N*logN) 堆排序O(N*logN) 基数排序O(d(n+...

    aboutU 评论0 收藏0
  • Github标星2w+,热榜第一,如何用Python实现所有算法

    摘要:归并排序归并排序,或,是创建在归并操作上的一种有效的排序算法,效率为大符号。以此类推,直到所有元素均排序完毕。与快速排序一样都由托尼霍尔提出的,因而也被称为霍尔选择算法。 showImg(https://segmentfault.com/img/remote/1460000019096360);编译:周素云、蒋宝尚 学会了Python基础知识,想进阶一下,那就来点算法吧!毕竟编程语言只...

    zxhaaa 评论0 收藏0
  • 几种排序算法Python 实现

    摘要:因为直接插入排序在元素基本有序的情况下接近最好情况,效率是很高的,因此希尔排序在时间效率上比前两种方法有较大提高。 插入排序 def insert_sort(list): n = len(list) for i in range(1, n): key = list[i] for j in range(i-1, -1, -1): ...

    cod7ce 评论0 收藏0
  • 数据结构与算法:常见排序算法

    摘要:这是一个简单的递归函数,你可以使用它来生成数列中指定序号的数值这个函数的问题在于它的执行效率非常低有太多值在递归调用中被重新计算。 本章内容衔接上一章 数据结构与算法:二分查找 内容提要 两种基本数据结构: 数组 常见操作: 数组降维、数组去重 链表 递归:递归是很多算法都使用的一种编程方法   - 如何将问题分成基线条件和递归条件   - 分而治之策略解决棘手问题 ...

    wuyumin 评论0 收藏0
  • 数据结构与算法:常见排序算法

    摘要:这是一个简单的递归函数,你可以使用它来生成数列中指定序号的数值这个函数的问题在于它的执行效率非常低有太多值在递归调用中被重新计算。 本章内容衔接上一章 数据结构与算法:二分查找 内容提要 两种基本数据结构: 数组 常见操作: 数组降维、数组去重 链表 递归:递归是很多算法都使用的一种编程方法   - 如何将问题分成基线条件和递归条件   - 分而治之策略解决棘手问题 ...

    Carson 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<