文章目录

排序的分类
排序的复杂度
python 实现
- 冒泡排序
- 选择排序
- 插入排序
- 希尔排序
- 归并排序
- 堆排序
- 快排
- 树排序
线性时间排序算法
- 计数排序
- 桶排序
- - 桶排序的复杂度分析
- 基数排序

排序的分类

基准	解释
按比较次数	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))、 O ( n 2 ) O(n^2) O(n2)、 O ( n ) O(n) O(n)
按交换次数
按内存占用	需要多少额外空间
按是否递归	比如快排是递归算法，选择、插入排序是非递归算法
按稳定性	是否保持相同 key 排序前后的相对次序
按适应性	是否受到初始顺序的影响，有些算法对预排序的数组有较好的性能
按是否需要内存之外的存储	内排序、外排序

排序的复杂度

排序算法	额外空间复杂度	最好时间间复杂度	最坏时间复杂度	平均时间复杂度	稳定性
冒泡排序	O ( 1 ) O(1) O(1)	O ( n ) O(n) O(n)	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	是
选择排序	O ( 1 ) O(1) O(1)	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	否
插入排序	O ( 1 ) O(1) O(1)	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	是
希尔排序	O ( 1 ) O(1) O(1)	O ( n ) O(n) O(n)	O ( n log ⁡ 2 ( n ) ) O(n\log^2(n)) O(nlog2(n))	-	否
归并排序	O ( n ) O(n) O(n)	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	是
堆排序	O ( 1 ) O(1) O(1)	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	否
快排	O ( log ⁡ ( n ) ) O(\log(n)) O(log(n))	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	O ( n 2 ) O(n^2) O(n2)	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	-
树排序	O ( n ) O(n) O(n)	-	O ( n 2 ) O(n^2) O(n2)	O ( n log ⁡ ( n ) ) O(n\log(n)) O(nlog(n))	-

python 实现

def swap(A, x, y):A[x], A[y] = A[y], A[x]

冒泡排序

def BubbleSort(A):for i in range(len(A)):for k in range(len(A) - 1, i, -1):if (A[k] < A[k - 1]):swap(A, k, k-1)

改进: 如果第一次遍历，没有发生交换，说明已经排好序了，直接结束，对最好情况的时间复杂度为 O ( n ) O(n) O(n)

def BubbleSort(A):swapped = Truefor i in range(len(A)):if not swapped:returnfor k in range(len(A) - 1, i, -1):if (A[k] < A[k - 1]):swap(A, k, k-1)swapped = True

选择排序

def SelectionSort(A):for i in range(len(A)):least = ifor k in range(i + 1, len(A)):if A[k] < A[least]:least = kswap(A, least, i)

插入排序

def InsertionSort(A):for i in range(1, len(A)):tmp = A[i]k = iwhile k > 0 and tmp < A[k - 1]:A[k] = A[k - 1]k -= 1A[k] = tmp

希尔排序

def ShellSort(A):sublistcount = len(A) // 2while sublistcount > 0:for startposition in range(sublistcount):gapInsertionSort(A, startposition, sublistcount)# print("After increments of size", sublistcount, "The list is", A)sublistcount = sublistcount // 2def gapInsertionSort(A, start, gap):for i in range(start + gap, len(A), gap):currentvalue = A[i]position = iwhile position >= gap and A[position - gap] > currentvalue:A[position] = A[position - gap]position = position - gapA[position] = currentvalue

归并排序

def MergeSort(A):if len(A) > 1:mid = len(A) // 2lefthalf = A[:mid]righthalf = A[mid:]MergeSort(lefthalf)MergeSort(righthalf)i = j = k = 0while i < len(lefthalf) and j < len(righthalf):if lefthalf[i] < righthalf[j]:A[k] = lefthalf[i]i = i + 1else:A[k] = righthalf[j]j = j + 1k = k + 1while i < len(lefthalf):A[k] = lefthalf[i]i = i + 1k = k + 1while j < len(righthalf):A[k] = righthalf[j]j = j + 1k = k + 1

堆排序

参见 python 数据结构与算法——优先队列和堆

快排

如果不计空间成本，下面是最直观的实现，完美诠释分治的思想

def partition(A):pivot, A = A[0], A[1:]low = [x for x in seq if x <= pivot]high = [x for x in seq if x > pivot]return low, pivot, highdef quickSort(A):if len(A) <= 1:return Alow, pivot, high = partition(A)return quickSort(low) + [pivot] + quickSort(high)

下面是个中规中矩的快排，随机选取分割点

import randomdef QuickSort(A, low, high):if low < high:pivot = Partition(A, low, high)QuickSort(A, low, pivot - 1)QuickSort(A, pivot + 1, high)def Partition(A, low, high):pivot = low + random.randrange(high - low + 1)swap(A, pivot, high)for i in range(low, high):if A[i] <= A[high]:swap(A, i, low)low += 1swap(A, low, high)return low

树排序

使用二叉排序树，参见二叉树排序算法

线性时间排序算法

计数排序

如果已知数组 A 的最大值小于 k，那么可以在 O ( n + k ) O(n+k) O(n+k) 时间内完成排序，空间复杂度 O ( k ) O(k) O(k)

def counting_sort(A, k):C = [0] * kfor a in A:C[a] += 1           i = 0for a in range(k):for c in range(C[a]): A[i] = ai += 1return Aprint(counting_sort( [1, 4, 7, 2, 1, 3, 2, 1, 4, 2, 3, 2, 1], 8 ))

桶排序

桶排序和计数排序类似，如果已知元素的范围，如： [ m i n , m a x ] [min, max] [min,max]，那么

先把这个区间 [ m i n , m a x ] [min, max] [min,max] 分成 K K K 个子区间（桶），此时这些区间的顺序是已知的
遍历数组，把元素这个放进这 K K K 个桶
对每个桶内元素排序
依次读取各个桶内的元素

桶排序的复杂度分析

总元素有 N N N 个，每个桶内的元素平均有 N / K N/K N/K 个

如果对每个桶采用复杂度为 O ( n 2 ) O(n^2) O(n2) 的排序算法，即 O ( N 2 / K 2 ) O(N^2/K^2) O(N2/K2)，那么 K K K 个桶就需要 O ( N 2 / K ) O(N^2/K) O(N2/K) 的时间

最后读取所有元素，需要 O ( N ) O(N) O(N)

所以总的时间代价为： T ( N ) = O ( N 2 / K ) + O ( N ) T(N) = O(N^2/K) + O(N) T(N)=O(N2/K)+O(N)

平平无奇

python 数据结构与算法——排序相关推荐

python数据结构和算法时间复杂度分析乱序单词检测线性数据结构栈stack 字符匹配表达式求值 queue队列链表递归动态规划排序和搜索树图
python数据结构和算法参考本文github 计算机科学是解决问题的研究.计算机科学使用抽象作为表示过程和数据的工具.抽象的数据类型允许程序员通过隐藏数据的细节来管理问题领域的复杂性.Pytho ...
Python天天美味(32) - python数据结构与算法之堆排序
1. 选择排序选择排序原理是先选出最小的数,与第一个数交换,然后从第二个数开始再选择最小的数与第二个数交换,-- def selection_sort(data): for i in ran ...
python数据结构与算法13_python 数据结构与算法 (13)
python 数据结构与算法 (13) 选择排序 (Selection sort) 是? 种简单直观的排序算法. 它的? 作原理如下.? 先在未排序序列中找到最?(?)元素, 存放到排序序列的起始位 ...
Python 数据结构与算法——快排
Python 数据结构与算法--选取算法(TopK) 如果说快速选取法所代表的是剪枝式的遍历操作--在递归树中找出一条通往第 k<script type="math/tex" ...
python数据结构与算法练习-Printer Queue
python数据结构与算法练习-队列 Printer Queue python实现需要注意的知识点: Printer Queue 链接: link. The only printer in the ...
[FreeCodeCamp笔记] Python 数据结构和算法1 二分搜索 Binary Search
我以前学过数据结构和算法(data structure and algorithms. 现在普遍简称DSA),当时用的Robert Sedgewick的coursera课程.这位大神写的<算法( ...
视频教程-Python数据结构与算法面试（上）-Python
Python数据结构与算法面试(上) 东北大学计算机专业硕士研究生,欧瑞科技创始人&CEO,曾任国内著名软件公司项目经理,畅销书作者,企业IT内训讲师,CSDN学院专家讲师,制作视频课程超过1 ...
python leetcode_leetcode 介绍和 python 数据结构与算法学习资料
for (刚入门的编程)的高中 or 大学生 leetcode 介绍 leetcode 可以说是 cs 最核心的一门"课程"了,虽然不是大学开设的,但基本上每一个现代的高水平的程序 ...
Python数据结构与算法（二）栈和队列
本系列总结了python常用的数据结构和算法,以及一些编程实现. 参考书籍:<数据结构与算法 Python语言实现> [美]Michael T.Goodrich, Roberto Tama ...

python 数据结构与算法——排序