**系列合集：** [数据结构大合集](https://juejin.cn/post/6981018609900322830) [算法 - 1. 十大排序算法](https://juejin.cn/post/6985144003716972558) # 算法 - 十大经典排序算法(动图演示) 在计算机科学与数学中，一个**排序算法**（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法。最常用到的排序方式是数值顺序以及字典顺序。排序算法也用在处理文字资料以及产生人类可读的输出结果。基本上，排序算法的输出必须遵守下列两个原则： 1. 输出结果为递增序列（递增是针对所需的排序顺序而言） 2. 输出结果是原输入的一种排列或是重组 ## 算法基本介绍十种排序算法一般分为两大类： - 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。（冒泡、选择、插入、归并、快速、希尔、堆排序） - 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。（计数、基数、桶）十种排序算法复杂度一览： ![image-20210713170142593](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2fe4366474464f8d91e6057f5e7a327a~tplv-k3u1fbpfcp-zoom-1.image) - n：数据规模 - k：进制数量(eg:十进制 k=1) - d：最大值的位数 - m：桶的数量 **名词解释：** - 稳定性：如果相等的两个元素，在排序前后的相对位置保持不变，那么这称之为**稳定**的排序算法 - In-place：不依赖额外的资源或者依赖少数的额外资源，仅依靠输出来覆盖输入 - 时间复杂度：指执行算法所需要的计算工作量。也就是说程序需要执行的次数 - 空间复杂度：对一个算法在运行过程中临时占用存储空间大小的量度 ## baseCode 为方便其他算法的测试与实现搞了一写base代码可忽略 ```swift class BaseSort: NSObject { var arrayList = [NSInteger]() // 需要排序的数组 var swapCount = 0 // 交换次数 var cmpCount = 0 // 比较次数 fileprivate func sort(array: [NSInteger]) { arrayList = array let startTime = CFAbsoluteTimeGetCurrent() sortAction() let endTime = CFAbsoluteTimeGetCurrent() let sortTitle = self.className print(""" 【\(sortTitle)】执行时间：\(endTime - startTime) 比较次数：\(cmpCount) 交换次数：\(swapCount) --------------------------------------------------------------------------------- """) print(arrayList) } func sortAction(){ } /// 比较两个元素的大小等于0:v1=v2 小于0:v1v2 func cmpValue(_ v1: NSInteger, _ v2: NSInteger) -> Int { return v1 - v2 } func cmpIndex(_ index1: NSInteger, _ index2: NSInteger) -> Int { let v1 = arrayList[index1] let v2 = arrayList[index2] cmpCount += 1 return cmpValue(v1, v2) } func swap(_ index1: NSInteger, _ index2: NSInteger) { let temp = arrayList[index1] arrayList[index1] = arrayList[index2] arrayList[index2] = temp swapCount += 1 } } /// 创建一个随机数组 func createRandom(count: NSInteger, min: NSInteger, max: NSInteger) -> [NSInteger]{ var array = [NSInteger]() for _ in 0.. 0 { min = begin+1 } } swap(i, min) } } ``` - 方案对比结果 ```swift ``` ## 3. 堆排序(Heapsort) 堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子节点的键值或者索引总是小于（或者大于）他的父节点堆排序也可以看做是选择排序的一种优化方案 [想要了解更多二叉树堆等数据结构相关知识请移步~](https://juejin.cn/post/6981018609900322830) ### 1.1 算法描述 **涉及到`原地建堆`的基本公式及概念：** 1. 父节点`i`的左子节点的位置：2i+1 2. 父节点`i`的右子节点的位置：2i+2 3. 子节点`i`的父节点的位置： (i-1)/2 4. 完全二叉树中第一个非叶子节点的位置：元素个数/2 **算法描述** 1. 原地建堆 2. 交换堆顶元素与尾部元素 3. 对的元素数量减少1 4. 对0的位置进行一次siftDown(恢复堆的特性) 5. 重复 2、3、4步骤 ### 1.2 动图演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fd2cf872b12f446991e1fc242f7542bb~tplv-k3u1fbpfcp-zoom-1.image) ### 1.3 代码实现 - 方案 ```swift /// 堆排序 class HeapSort: BaseSort { var heapSize = 0 override func sortAction() { heapSize = arrayList.count var i = heapSize >> 1 - 1 while i >= 0 { siftDown(i) i-=1 } while heapSize >= 1 { heapSize-=1 // 忽略已经交换的值 swap(0, heapSize) // 交换尾部和顶部元素 siftDown(0) // 恢复堆的性质 } } // 原地建堆 func siftDown(_ downIndex: Int) { let half = heapSize >> 1 let value = arrayList[downIndex] var index = downIndex while index < half { // index 必须是非叶子节点 var childIndex = (index << 1)+1 var child = arrayList[childIndex] let rightIndex = childIndex + 1 if rightIndex < heapSize && (cmpValue(arrayList[rightIndex], child) > 0){ childIndex = rightIndex child = arrayList[rightIndex] } if cmpValue(value, child) >= 0 { break } arrayList[index] = child index = childIndex } arrayList[index] = value } } ``` - 方案对比结果 ```swift ``` ## 4. 插入排序(Insertion Sort) 插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序的数据，在已排序的序列中从后向前扫描，找到响应的位置并插入。插入排序在实现上，通常采用In-place排序（即只需要使用O(1)的额外空间），因而在从后向前的扫描过程中，需要反复把已排序的元素逐步向后挪位，为最新的元素提供插入空间。插入排序类似于扑克牌的排序可以根据日常打扑克时的思维去思考 ### 4.1 算法描述 1. 从第一个元素开始，默认为第一个元素是已经被排序的 2. 取出下一个元素，在已排序的序列中从后向前扫描 3. 如果该元素大于取出元素，则向后挪动 4. 重复步骤3 直到在已排序好的序列中找到小于或等于取出的元素的位置 5. 将取出的元素插入带该元素的位置 6. 重复步骤 2~5 ### 4.2 动图演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d5ae17e6956f478fa3ec261621cdeee9~tplv-k3u1fbpfcp-zoom-1.image) ### 4.3 代码实现 - 方案： ```swift override func sortAction() { for i in 1.. 0 && cmpValue(arrayList[begin-1], value) > 0 { arrayList[begin] = arrayList[begin-1] begin -= 1 } arrayList[begin] = value } } ``` ## 5. 归并排序(Merge sort) 归并排序是创建在归并操作上的一种有效的排序算法，效率为O(nlogn).1945年由[约翰·冯·诺伊曼](https://zh.wikipedia.org/wiki/约翰·冯·诺伊曼)首次提出。该算法是采用分治法的一个非常典型的应用，且各层分支递归可同时进行。归并操作：指的是将两个已经排序的序列合并成一个序列的操作，归并排序算法依赖归并操作 ### 5.1 算法描述

1. 不断的将当前序列分割成两个子序列 - 直到不能分割（序列中只有一个元素） 2. 不断的将2个子序列合并成一个有序的序列 - 合并需要临时变量： - li：左侧序列开始位置 le：左侧序列截止位置 - ri：右侧序列开始位置 re：右侧序列截止位置 - ai：当前插入位置 - 提前将左侧的序列拿出来，用来循环拿去当前左侧序列的值 - 一次对比左右序列中值的大小之后想[ai]处覆盖。

3. 直到最终只剩下一个序列 ### 5.2 动图演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/06bef044b6e44470b6be2a1a61fd63a1~tplv-k3u1fbpfcp-zoom-1.image) ### 5.3 代码实现 - 方案 ```swift /// 归并排序 class MergeSort: BaseSort { var leftArray = [NSInteger]() override func sortAction() { leftArray = [NSInteger](repeating: 0, count: arrayList.count >> 1) divide(0, arrayList.count) } // 分割 func divide(_ begin: NSInteger, _ end: NSInteger){ if end - begin < 2 { return } let mid = (begin+end) >> 1 divide(begin, mid) divide(mid, end) merge(begin, mid, end) } // 合并 func merge(_ begin: NSInteger, _ mid: NSInteger, _ end: NSInteger){ var li = 0, le = mid-begin var ri = mid, re = end var ai = begin for i in li.. NSInteger { // 随机一个基准值元素与第一个交换 let random = Int(arc4random_uniform(UInt32(end-begin)))+begin swap(begin, random) let pivotValue = arrayList[begin] var beginIndex = begin var endIndex = end while beginIndex < endIndex { while beginIndex < endIndex { if cmpValue(pivotValue, arrayList[endIndex]) < 0 { endIndex-=1 }else{ arrayList[beginIndex] = arrayList[endIndex] beginIndex+=1 break } } while beginIndex < endIndex { if cmpValue(pivotValue, arrayList[beginIndex]) > 0 { beginIndex+=1 }else{ arrayList[endIndex] = arrayList[beginIndex] endIndex-=1 break } } } arrayList[beginIndex] = pivotValue return beginIndex } } ``` ## 7. 希尔排序(Shellsort) 希尔排序，也称递减增量排序算法，是插入排序的一种高效改进版本，希尔排序是非常稳定的排序算法希尔排序是基于插入排序的以下两点性质而提出的改进方法： - 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率 - 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位 **步长序列** 步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。算法最开始以一定的步长进行排序。然后会继续以一定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为普通插入排序，这就保证了数据一定会被排序。 Donald Shell最初建议步长选择为n/2并且对步长取半直到步长达到1。虽然这样取可以比O(n^2)类的算法（插入排序)更好，但这样仍然有减少平均时间和最差时间的余地目前已知的最好步长序列是由Sedgewick提出的`(1, 5, 19, 41, 109,...)`. ### 7.1 算法描述希尔排序是吧序列看成一个矩阵，分成m列，逐列进行排序 - m从某个整数逐渐减为1 - 当m为1 时整个序列将完全有序矩阵的列数取决于步长序列 - 如果步长序列为[1,5,19,41,109...],就代表一次分成 109列，41列，19列，5列，1列进行排序 - 不同的步长序列执行的效率也不同 **概念** 1. 假设元素在第col列，第row行，步长（总列数）是step

- 这个元素在数组中的索引 col+row*step - 例如 9在序列的第二列，第0行， 2+0*5 = 2 ### 7.2 动图演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9324151ef0334e87a44b7549b24eae97~tplv-k3u1fbpfcp-zoom-1.image) ### 7.3 代码实现 - 方案 ```swift class ShellSort: BaseSort { override func sortAction() { let stepSequence = sedgewickStepSequence() // 步长序列 for step in stepSequence { sort(step) } } func sort(_ step:NSInteger){ for col in 0.. col && cmpValue(value,arrayList[cur-step]) < 0 { arrayList[cur] = arrayList[cur-step] cur -= step } arrayList[cur] = value begin += step } } } /// 步长序列实现方式 /// - Returns: [1,5,19,41,109...] func sedgewickStepSequence() -> [NSInteger] { var stepSequence = [NSInteger]() var k = 0, step = 0 while true { if k % 2 == 0 { let powNum:Int = Int(pow(CGFloat(2), CGFloat(k>>1))) step = 1+9*(powNum * powNum - powNum) }else{ let powNum1:Int = Int(pow(CGFloat(2), CGFloat((k-1)>>1))) let powNum2:Int = Int(pow(CGFloat(2), CGFloat((k+1)>>1))) step = 1 + 8 * powNum1 * powNum2 - 6 * powNum2 } if step >= arrayList.count { break } stepSequence.insert(step, at: 0) k+=1 } return stepSequence } } ``` ## 8. 计数排序(Counting sort) 计数排序是一种稳定的线性时间排序算法。该算法于1954年由 Harold H. Seward 提出。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序算法中，能够更有效的排序数据范围很大的数组。 #### 8.1 算法描述 - 找出待排序的数组中最大和最小的元素； - 统计数组中每个值为i的元素出现的次数，存入数组C的第i项； - 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）； - 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。 ### 8.2 动画演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/04512da486d04bd192b673e54aaba6b4~tplv-k3u1fbpfcp-zoom-1.image) ### 8.3 代码实现 - 方式 ```java class CountingSort: BaseSort { override func sortAction() { guard arrayList.count > 0 else { return } let maxElement = arrayList.max() ?? 0 var countArray = [Int](repeating: 0, count: Int(maxElement + 1)) for element in arrayList { countArray[element] += 1 } for index in 1 ..< countArray.count { let sum = countArray[index] + countArray[index - 1] countArray[index] = sum } // 输出 for element in arrayList { countArray[element] -= 1 arrayList[countArray[element]] = element } } } ``` ## 9. 基数排序(Radix sort) 基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。 ### 9.1 算法描述 1. 一次对个位数、十位数、百位数、千位数...进行排序（从低位到高位） 2. 个位十位百位数的取值范围都是0~9，可以使用计数排序对他们进行排序 ### 9.2 动图演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/79ebe735b9c443feb9be328ba112bcf7~tplv-k3u1fbpfcp-zoom-1.image) ### 9.3 代码实现 - 方式 ```swift class RadixStor: BaseSort { override func sortAction() { var tempArray = [Int]() var maxValue = 0 var maxDigit = 0 var level = 0 repeat { var buckets = [[Int]]() for _ in 0..<10 { buckets.append([Int]()) } for i in 0.. maxValue { maxValue = elementValue } } } tempArray.removeAll() for element in buckets { tempArray.append(contentsOf: element) } if maxDigit == 0 { while maxValue > 0 { maxValue = maxValue / 10 maxDigit += 1 } } arrayList = tempArray level += 1 } while (level < maxDigit) } } ``` ## 10. 桶排序(Bucket sort) 桶排序或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。但桶排序并不是比较排序，他不受到O(nlogn)下限的影响。 ### 10.1 算法描述 1. 创建一定数量的桶（比如用数组链表作为桶） 2. 按照一定规则（不同类型的数据，规则不同）将序列中的元素均匀分配到对应的桶中 3. 分别对每个桶进行单独排序 4. 将所有非空桶元素合并成有序序列 ### 10.2 动图演示 ![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f9e7c7fe42d44ee1b5efc9b2aafa0e55~tplv-k3u1fbpfcp-zoom-1.image) ### 10.3 代码实现 - 方案 ```swift override func sortAction() { let maxNum = arrayList.max() var bucket:[Int] = Array.init(repeatElement(0, count: maxNum! + 1)) var newNum:[Int] = Array.init() for index in arrayList { let numId = index bucket[numId] += 1 } for index in bucket.indices { while bucket[index] > 0 { newNum.append(index) bucket[index] -= 1 } } arrayList = newNum } ``` ## 效率对比： ### 非比较类： ```swift var sortArray = createRandom(count: 10000, min: 0, max: 100000) testSorts(array: sortArray, CountingSort(), // 计数排序 RadixStor(), // 基数排序 BucketSort() // 桶排序 ) 【算法.CountingSort】执行时间：0.09470701217651367 --------------------------------------------------------------------------------- 【算法.RadixStor】执行时间：0.07344508171081543 --------------------------------------------------------------------------------- 【算法.BucketSort】执行时间：0.168626070022583 --------------------------------------------------------------------------------- ``` **计数排序**需要占用大量空间，它仅适用于数据比较集中的情况。比如 [0~100]，[10000~19999] 这样的数据。 **桶排序**可用于最大最小值相差较大的数据情况，比如[9012,19702,39867,68957,83556,102456]。但桶排序要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中。比如[104,150,123,132,20000], 这种数据会导致前4个数都集中到同一个桶中。导致桶排序失效。 **基数排序**一般用于长度相同的元素组成的数组。基数排序可以看做是进行多趟桶排序。每个有效数字都在0-9之间，很适合桶排序，建10个桶很方便 ### 比较类算法： - **冒泡排序01、冒泡排序02、选择排序、插入排序一起比较因为这个耗时比较长** - **数据规模1000** ```swift var sortArray = createRandom(count: 1000, min: 0, max: 10000) testSorts(array: sortArray, BubbleSort01(), BubbleSort02(), SelectSort01(), InsertionSort01() ) 【算法.BubbleSort01】执行时间：0.6120259761810303 比较次数：499500 交换次数：248498 --------------------------------------------------------------------------------- 【算法.BubbleSort02】执行时间：0.6053379774093628 比较次数：499500 交换次数：248498 --------------------------------------------------------------------------------- 【算法.SelectSort01】执行时间：0.4609769582748413 比较次数：499500 交换次数：1000 --------------------------------------------------------------------------------- 【算法.InsertionSort01】执行时间：0.12423503398895264 比较次数：249485 交换次数：0 --------------------------------------------------------------------------------- ``` - **堆排序、归并排序。快速排序、希尔排序 ** - **数据规模1万** ```swift var sortArray = createRandom(count: 10000, min: 0, max: 100000) testSorts(array: sortArray, HeapSort(), MergeSort(), QuickSort(), ShellSort() ) 【算法.HeapSort】执行时间：0.13575303554534912 比较次数：235379 交换次数：10000 --------------------------------------------------------------------------------- 【算法.MergeSort】执行时间：0.2747499942779541 比较次数：120561 交换次数：0 --------------------------------------------------------------------------------- 【算法.QuickSort】执行时间：0.1792229413986206 比较次数：150138 交换次数：6625 --------------------------------------------------------------------------------- 【算法.ShellSort】执行时间：0.3527510166168213 比较次数：196090 交换次数：0 --------------------------------------------------------------------------------- ``` ![image-20210713170142593](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/bfc36591f02b44b7b0c176d6946c8d05~tplv-k3u1fbpfcp-zoom-1.image) 最后还是这张图大家可以根据需求酌情选择~~ END~ 参考： - 维基百科 - 恋上数据结构与算法 - https://www.jianshu.com/p/bd6860146214 - https://www.cnblogs.com/onepixel/p/7674659.html - https://blog.csdn.net/donghuabianc/article/details/105252373 - https://www.cnblogs.com/jiangfan95/p/11498625.html