用Python实现十大经典排序算法!

排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

1、冒泡排序

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

(1)算法步骤
  1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤,除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

(2)动图演示

(3)Python 代码

1 def bubbleSort(arr):
2 for i in range(1, len(arr)):
3 for j in range(0, len(arr)-i):
4 if arr[j] > arr[j+1]:
5 arr[j], arr[j + 1] = arr[j + 1], arr[j]
6 return arr

2、选择排序

选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。

(1)算法步骤

  1. 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置
  2. 再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
  3. 重复第二步,直到所有元素均排序完毕。

(2)动图演示

(3)Python 代码

 1 def selectionSort(arr):
2 for i in range(len(arr) - 1):
3 # 记录最小数的索引
4 minIndex = i
5 for j in range(i + 1, len(arr)):
6 if arr[j] < arr[minIndex]:
7 minIndex = j
8 # i 不是最小数时,将 i 和最小数进行交换
9 if i != minIndex:
10 arr[i], arr[minIndex] = arr[minIndex], arr[i]
11 return arr

3、插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴,但它的原理应该是最容易理解的了,因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序和冒泡排序一样,也有一种优化算法,叫做拆半插入。

(1)算法步骤

  1. 将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
  2. 从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)

(2)动图演示

(3)Python 代码

1 def insertionSort(arr):
2 for i in range(len(arr)):
3 preIndex = i-1
4 current = arr[i]
5 while preIndex >= 0 and arr[preIndex] > current:
6 arr[preIndex+1] = arr[preIndex]
7 preIndex-=1
8 arr[preIndex+1] = current
9 return arr

4、希尔排序

也称递减增量排序算法,是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。希尔排序是基于插入排序的以下两点性质而提出改进方法的:

  • 插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;
  • 但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位;

希尔排序的基本思想是:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序。

(1)算法步骤

  1. 选择一个增量序列 t1,t2,……,tk,其中 ti > tj, tk = 1;
  2. 按增量序列个数 k,对序列进行 k 趟排序;
  3. 每趟排序,根据对应的增量 ti,将待排序列分割成若干长度为 m 的子序列,分别对各子表进行直接插入排序。仅增量因子为 1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。

(2)动图演示

(3)Python 代码

 1 def shellSort(arr):
2 import math
3 gap=1
4 while(gap < len(arr)/3):
5 gap = gap*3+1
6 while gap > 0:
7 for i in range(gap,len(arr)):
8 temp = arr[i]
9 j = i-gap
10 while j >=0 and arr[j] > temp:
11 arr[j+gap]=arr[j]
12 j-=gap
13 arr[j+gap] = temp
14 gap = math.floor(gap/3)
15 return arr

5、归并排序

归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。作为一种典型的分而治之思想的算法应用,归并排序的实现由两种方法:

  • 自上而下的递归(所有递归的方法都可以用迭代重写,所以就有了第 2 种方法);
  • 自下而上的迭代;

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

(1)算法步骤

  1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;
  2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置;
  3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;
  4. 重复步骤 3 直到某一指针达到序列尾;
  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

(2)动图演示

(3)Python 代码

 1 def mergeSort(arr):
2 import math
3 if(len(arr)<2):
4 return arr
5 middle = math.floor(len(arr)/2)
6 left, right = arr[0:middle], arr[middle:]
7 return merge(mergeSort(left), mergeSort(right))
8
9 def merge(left,right):
10 result = []
11 while left and right:
12 if left[0] <= right[0]:
13 result.append(left.pop(0));
14 else:
15 result.append(right.pop(0));
16 while left:
17 result.append(left.pop(0));
18 while right:
19 result.append(right.pop(0));
20 return result

 

6、快速排序

在平均状况下,排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较,但这种状况并不常见。事实上,快速排序通常明显比其他 Ο(nlogn) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看,快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的最坏运行情况是 O(n²),比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn),且 O(nlogn) 记号中隐含的常数因子很小,比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以,对绝大多数顺序性较弱的随机数列而言,快速排序总是优于归并排序。

(1)算法步骤

  1. 从数列中挑出一个元素,称为 “基准”(pivot);
  2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
  3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

(2)动图演示

(3)Python 代码

 1 def quickSort(arr, left=None, right=None):
2 left = 0 if not isinstance(left,(int, float)) else left
3 right = len(arr)-1 if not isinstance(right,(int, float)) else right
4 if left < right:
5 partitionIndex = partition(arr, left, right)
6 quickSort(arr, left, partitionIndex-1)
7 quickSort(arr, partitionIndex+1, right)
8 return arr
9
10 def partition(arr, left, right):
11 pivot = left
12 index = pivot+1
13 i = index
14 while i <= right:
15 if arr[i] < arr[pivot]:
16 swap(arr, i, index)
17 index+=1
18 i+=1
19 swap(arr,pivot,index-1)
20 return index-1
21
22 def swap(arr, i, j):
23 arr[i], arr[j] = arr[j], arr[i]

 

7、堆排序

利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法:
  1. 大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用于升序排列;
  2. 小顶堆:每个节点的值都小于或等于其子节点的值,在堆排序算法中用于降序排列;

堆排序的平均时间复杂度为 Ο(nlogn)。

(1)算法步骤
  1. 创建一个堆 H[0……n-1];
  2. 把堆首(最大值)和堆尾互换;
  3. 把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;
  4. 重复步骤 2,直到堆的尺寸为 1。

(2)动图演示

(3)Python 代码

 1 def buildMaxHeap(arr):
2 import math
3 for i in range(math.floor(len(arr)/2),-1,-1):
4 heapify(arr,i)
5
6 def heapify(arr, i):
7 left = 2*i+1
8 right = 2*i+2
9 largest = i
10 if left < arrLen and arr[left] > arr[largest]:
11 largest = left
12 if right < arrLen and arr[right] > arr[largest]:
13 largest = right
14
15 if largest != i:
16 swap(arr, i, largest)
17 heapify(arr, largest)
18
19 def swap(arr, i, j):
20 arr[i], arr[j] = arr[j], arr[i]
21
22 def heapSort(arr):
23 global arrLen
24 arrLen = len(arr)
25 buildMaxHeap(arr)
26 for i in range(len(arr)-1,0,-1):
27 swap(arr,0,i)
28 arrLen -=1
29 heapify(arr, 0)
30 return arr

 

8、计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

(1)动图演示

(2)Python 代码

 1 def countingSort(arr, maxValue):
2 bucketLen = maxValue+1
3 bucket = [0]*bucketLen
4 sortedIndex =0
5 arrLen = len(arr)
6 for i in range(arrLen):
7 if not bucket[arr[i]]:
8 bucket[arr[i]]=0
9 bucket[arr[i]]+=1
10 for j in range(bucketLen):
11 while bucket[j]>0:
12 arr[sortedIndex] = j
13 sortedIndex+=1
14 bucket[j]-=1
15 return arr

 

9、桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:
  1. 在额外空间充足的情况下,尽量增大桶的数量
  2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。

什么时候最快

当输入的数据可以均匀的分配到每一个桶中。

什么时候最慢

当输入的数据被分配到了同一个桶中。

Python 代码

 1 def bucket_sort(s):
2 """桶排序"""
3 min_num = min(s)
4 max_num = max(s)
5 # 桶的大小
6 bucket_range = (max_num-min_num) / len(s)
7 # 桶数组
8 count_list = [ [] for i in range(len(s) + 1)]
9 # 向桶数组填数
10 for i in s:
11 count_list[int((i-min_num)//bucket_range)].append(i)
12 s.clear()
13 # 回填,这里桶内部排序直接调用了sorted
14 for i in count_list:
15 for j in sorted(i):
16 s.append(j)
17
18 if __name__ == __main__ :
19 a = [3.2,6,8,4,2,6,7,3]
20 bucket_sort(a)
21 print(a) # [2, 3, 3.2, 4, 6, 6, 7, 8]

 

10、基数排序

基数排序是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。

基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法:这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:

  • 基数排序:根据键值的每位数字来分配桶;
  • 计数排序:每个桶只存储单一键值;
  • 桶排序:每个桶存储一定范围的数值;

动图演示

Python 代码

 1 def RadixSort(list):
2 i = 0 #初始为个位排序
3 n = 1 #最小的位数置为1(包含0)
4 max_num = max(list) #得到带排序数组中最大数
5 while max_num > 10**n: #得到最大数是几位数
6 n += 1
7 while i < n:
8 bucket = {} #用字典构建桶
9 for x in range(10):
10 bucket.setdefault(x, []) #将每个桶置空
11 for x in list: #对每一位进行排序
12 radix =int((x / (10**i)) % 10) #得到每位的基数
13 bucket[radix].append(x) #将对应的数组元素加入到相 #应位基数的桶中
14 j = 0
15 for k in range(10):
16 if len(bucket[k]) != 0: #若桶不为空
17 for y in bucket[k]: #将该桶中每个元素
18 list[j] = y #放回到数组中
19 j += 1
20 i += 1
21 return list
 

python基础__十大经典排序算法的更多相关文章

  1. 用Python实现十大经典排序算法-插入、选择、快速、冒泡、归并等

    本文来用图文的方式详细讲解了Python十大经典排序算法 —— 插入排序.选择排序.快速排序.冒泡排序.归并排序.希尔排序.插入排序.桶排序.基数排序.计数排序算法,想要学习的你们,继续阅读下去吧,如 ...

  2. 十大经典排序算法(python实现)(原创)

    个人最喜欢的排序方法是非比较类的计数排序,简单粗暴.专治花里胡哨!!! 使用场景: 1,空间复杂度 越低越好.n值较大: 堆排序 O(nlog2n) O(1) 2,无空间复杂度要求.n值较大: 桶排序 ...

  3. python实现十大经典排序算法

    Python实现十大经典排序算法 代码最后面会给出完整版,或者可以从我的Githubfork,想看动图的同学可以去这里看看: 小结: 运行方式,将最后面的代码copy出去,直接python sort. ...

  4. 十大经典排序算法最强总结(含Java、Python码实现)

    引言 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法.排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面 ...

  5. 十大经典排序算法+sort排序

    本文转自:十大经典排序算法,其中有动图+代码详解,本文简单介绍+个人理解. 排序算法 经典的算法问题,也是面试过程中经常被问到的问题.排序算法简单分类如下: 这些排序算法的时间复杂度等参数如下: 其中 ...

  6. JavaScript 数据结构与算法之美 - 十大经典排序算法汇总(图文并茂)

    1. 前言 算法为王. 想学好前端,先练好内功,内功不行,就算招式练的再花哨,终究成不了高手:只有内功深厚者,前端之路才会走得更远. 笔者写的 JavaScript 数据结构与算法之美 系列用的语言是 ...

  7. 十大经典排序算法的 JavaScript 实现

    计算机领域的都多少掌握一点算法知识,其中排序算法是<数据结构与算法>中最基本的算法之一.排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大 ...

  8. 一文搞定十大经典排序算法(Java实现)

    本文总结十大经典排序算法及变形,并提供Java实现. 参考文章: 十大经典排序算法总结(Java语言实现) 快速排序算法—左右指针法,挖坑法,前后指针法,递归和非递归 快速排序及优化(三路划分等) 一 ...

  9. 十大经典排序算法最强总结(含JAVA代码实现)(转)

    十大经典排序算法最强总结(含JAVA代码实现)   最近几天在研究排序算法,看了很多博客,发现网上有的文章中对排序算法解释的并不是很透彻,而且有很多代码都是错误的,例如有的文章中在“桶排序”算法中对每 ...

随机推荐

  1. 测试人员假装自己会“devops”

    目录 什么是DevOps DevOps岗位职责 DevOps的要求 如何增强DevOps能力 准备 服务器端安装jenkins Jenkins jenkins + maven 构建 jenkins下m ...

  2. CSS进阶内容—浮动和定位详解

    CSS进阶内容-浮动和定位详解 我们在学习了CSS的基本知识和盒子之后,就该了解一下网页的整体构成了 当然如果没有学习之前的知识,可以到我的主页中查看之前的文章:秋落雨微凉 - 博客园 CSS的三种布 ...

  3. Object类中wait带参方法和notifyAll方法和线程间通信

    notifyAll方法: 进入到Timed_Waiting(计时等待)状态有两种方式: 1.sleep(long m)方法,在毫秒值结束之后,线程睡醒,进入到Runnable或BLocked状态 2. ...

  4. day06 Java_数组_方法_参数

    精华笔记: 数组: 复制: System.arraycopy(a,1,b,0,4); int[ ] b = Arrays.copyOf(a,6); 排序: Arrays.sort(arr); //升序 ...

  5. Docker安装及基础命令

    一.docker安装 1.安装docker #关闭防火墙和selinux systemctl stop firewalld.service setenforce 0  ​ #安装依赖包 yum ins ...

  6. 部署yum仓库

    YUM介绍 YUM(全称为 Yellow dog Updater, Modified)是一个在Fedora和RedHat以及CentOS中的Shell前端软件包管理器. 基于RPM包管理,能够从指定的 ...

  7. Solution -「树状数组」 题目集合

    T1 冒泡排序 题目描述 clj 想起当年自己刚学冒泡排序时的经历,不禁思绪万千 当年,clj 的冒泡排序(伪)代码是这样的: flag=false while (not flag): flag=tr ...

  8. 【线性DP】数字三角形

    题目链接 原题链接 题目描述 给定一个如下图所示的数字三角形,从顶部出发,在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点,一直走到底层,要求找出一条路径,使路径上的数字的和最大. 7 3 ...

  9. typescript关于postgres数据库的API封装

    文章结构     1 新建 postgres.ts 文件     2 配置文件说明     3 依赖引用说明     4 API使用示例   1 新建 postgres.ts 文件,代码如下: imp ...

  10. ActiveMQ、RabbitMQ、RocketMQ、Kafka四种消息中间件分析介绍

    ActiveMQ.RabbitMQ.RocketMQ.Kafka四种消息中间件分析介绍 我们从四种消息中间件的介绍到基本使用,以及高可用,消息重复性,消息丢失,消息顺序性能方面进行分析介绍! 一.消息 ...