经典排序算法-堆排序heapsort
头歌数据结构十大经典排序算法 -回复
头歌数据结构十大经典排序算法-回复什么是经典排序算法？经典排序算法是指在计算机科学领域中被广泛应用和研究的排序算法。
排序是计算机科学中的基本操作之一，它的目标是将一组元素按照某种特定的顺序进行排列。
经典排序算法通常被用来解决排序问题，可以应用于数据的排序、搜索、统计等各种计算任务中。
在这篇文章中，我们将讨论头歌数据结构中的十大经典排序算法，探索每个算法的原理和实现方法，以及它们的优缺点和适用场景。
1. 冒泡排序（Bubble sort）冒泡排序是一种简单直观的排序算法，它的基本思想是重复地交换相邻两个元素，将较大的元素逐渐“浮”到数组的尾部。
具体实现可以使用两层嵌套循环，外层循环控制比较的轮数，内层循环进行元素比较和交换。
冒泡排序的时间复杂度为O(n^2)。
2. 选择排序（Selection sort）选择排序是一种简单的选择最小元素的排序算法，它的基本思想是从头开始，逐个选择最小的元素，并将其放置到已排序部分的末尾。
具体实现可以使用两层嵌套循环，外层循环控制已排序部分的末尾位置，内层循环用于选择最小元素。
选择排序的时间复杂度为O(n^2)。
3. 插入排序（Insertion sort）插入排序是一种简单直观的排序算法，它的基本思想是将已排序部分的元素依次与未排序部分的元素进行比较并插入到正确的位置。
具体实现可以使用两层嵌套循环，外层循环控制未排序部分的元素，内层循环用于比较和插入元素。
插入排序的时间复杂度为O(n^2)。
4. 希尔排序（Shell sort）希尔排序是一种改进的插入排序算法，它的基本思想是将数组划分为若干个子序列，并分别对子序列进行插入排序，直到整个数组有序。
具体实现使用增量序列来控制子序列的划分和插入排序的间隔，最终将整个数组排序。
希尔排序的时间复杂度为O(nlogn)。
5. 归并排序（Merge sort）归并排序是一种分治法排序算法，它的基本思想是将数组分成两个子数组，分别对子数组进行递归排序，然后将排序好的子数组合并成一个有序的数组。
堆 排 序 算 法
堆排序——C#实现一算法描述堆排序（Heap Sort）是利用一种被称作二叉堆的数据结构进行排序的排序算法。
二叉堆在内部维护一个数组，可被看成一棵近似的完全二叉树，树上每个节点对应数组中的一个元素。
除最底层外，该树是满的。
二叉堆中，有两个与所维护数组相关的属性。
Length表示数组的元素个数，而HeapSize则表示二叉堆中所维护的数组中的元素的个数（并不是数组中的所有元素都一定是二叉堆的有效元素）。
因此，根据上述定义有： 0 = HeapSize = Length。
二叉堆可分为最大堆和最小堆两种类型。
在最大堆中，二叉树上所有的节点都不大于其父节点，即 A[Parent(i)] = A[i]。
最小堆正好相反：A[Parent(i)] = A[i]。
为维护一个二叉堆是最大（小）堆，我们调用一个叫做MaxHeapify （MinHeapify）的过程。
以MaxHeapify，在调用MaxHeapify时，先假定根节点为Left(i)和Right(i)的二叉树都是最大堆，如果A[i]小于其子节点中元素，则交换A[i]和其子节点中的较大的元素。
但这样一来，以被交换的子节点为根元素的二叉堆有可能又不满足最大堆性质，此时则递归调用MaxHeapify方法，直到所有的子级二叉堆都满足最大堆性质。
如下图所示：因为在调用MaxHeapify（MinHeapify）方法使根节点为A[i]的二叉堆满足最大（小）堆性质时我们有其左右子堆均已满足最大（小）堆性质这个假设，所以如果我们在将一个待排序的数组构造成最大（小）堆时，需要自底向上地调用 MaxHeapify（MinHeapify）方法。
在利用最大堆进行排序时，我们先将待排序数组构造成一个最大堆，此时A[0]（根节点）则为数组中的最大元素，将A[0]与A[n - 1]交换，则把A[0]放到了最终正确的排序位置。
然后通过将HeapSize 减去1，将（交换后的）最后一个元素从堆中去掉。
堆排序实例演示
91 47 24 16 85 36 53 30
小顶堆 ：16，36，24，85，47，30，53，91
16 36 85 91 24
47 30 53
如果该序列是一个堆，则对应的这棵完全二叉树的特点是： 所有分支结点的值均不小于 (或不大于)其子女的值，即每棵 子树根结点的值是最大(或最小)的。 堆特点：堆顶元素是整个序列中最大(或最小)的元素。
仅需调整一次，
堆建成 。
2018/8/8
数据结构
7
第二个问题的背景： 输出堆顶元素后，将堆底元素送入堆顶（或将堆顶元素 与堆底元素交换），堆可能被破坏。 破坏的情况仅是根结点和其左右孩子之间可能不满足堆 的特性，而其左右子树仍然是局部的堆。
在这种情况下，将其R1 … Ri整理成堆。 （i=n-1..1)
2018/8/8
c.右子树不满 d.到了叶子结 足堆，继续调 点，调整结束， 整。 堆建成。
数据结构
6
85
30
53
53 47 85 91 30 36 16 85
47
24 91 36
53
16 30 91 24
47 36
16
24
堆调整结束。
R1 与 Rn-1 交换 ， 堆被破坏。 对 R1 与 Rn-2 调整。
91,47,85,24,36,53,30,16是一个大顶堆。
数据结构 1
在完全二叉树上，双亲和左右孩子之间的编号就是i和2i、 2i+1的关系。因此一个序列可以和一棵完全二叉树对应起来， 用双亲其左、右孩子之间的关系可以直观的分析是否符合堆 的特性。
大顶堆：91，47，85，24，36，53，30，16
2018/8/8
数据结构
php的9个经典排序算法
以下是使用PHP 实现的9个经典的排序算法：1. 冒泡排序```function bubble_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 0; $i < $n; $i++) {for ($j = 0; $j < $n - $i - 1; $j++) {if ($arr[$j] > $arr[$j+1]) {$temp = $arr[$j+1];$arr[$j+1] = $arr[$j];$arr[$j] = $temp;}}}return $arr;}```2. 选择排序```function selection_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 0; $i < $n; $i++) {$minIndex = $i;for ($j = $i+1; $j < $n; $j++) {if ($arr[$j] < $arr[$minIndex]) {$minIndex = $j;}}$temp = $arr[$i];$arr[$i] = $arr[$minIndex];$arr[$minIndex] = $temp;}return $arr;}```3. 插入排序```function insertion_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 1; $i < $n; $i++) {$value = $arr[$i];$j = $i - 1;for (; $j >= 0; $j--) {if ($arr[$j] > $value) {$arr[$j+1] = $arr[$j];} else {break;}}$arr[$j+1] = $value;}return $arr;}```4. 快速排序```function quick_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$pivotIndex = floor($n/2);$pivot = $arr[$pivotIndex];$left = array();$right = array();for ($i = 0; $i < $n; $i++) {if ($i == $pivotIndex) {continue;} else if ($arr[$i] < $pivot) {$left[] = $arr[$i];} else {$right[] = $arr[$i];}}return array_merge(quick_sort($left), array($pivot), quick_sort($right));}```5. 归并排序```function merge_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$mid = floor($n/2);$left = array_slice($arr, 0, $mid);$right = array_slice($arr, $mid);$left = merge_sort($left);$right = merge_sort($right);$newArr = array();while (count($left) && count($right)) {$newArr[] = $left[0] < $right[0] ? array_shift($left) : array_shift($right);}return array_merge($newArr, $left, $right);}```6. 堆排序```function heap_sort(&$arr) {$n = count($arr);if ($n <= 1) {return;}build_heap($arr);for ($i = $n-1; $i > 0; $i--) {$temp = $arr[0];$arr[0] = $arr[$i];$arr[$i] = $temp;heapify($arr, 0, $i);}}function build_heap(&$arr) {$n = count($arr);for ($i = floor($n/2)-1; $i >= 0; $i--) {heapify($arr, $i, $n);}}function heapify(&$arr, $i, $n) {$left = 2*$i+1;$right = 2*$i+2;$largest = $i;if ($left < $n && $arr[$left] > $arr[$largest]) {$largest = $left;}if ($right < $n && $arr[$right] > $arr[$largest]) {$largest = $right;}if ($largest != $i) {$temp = $arr[$i];$arr[$i] = $arr[$largest];$arr[$largest] = $temp;heapify($arr, $largest, $n);}}```7. 希尔排序```function shell_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$gap = floor($n/2);while ($gap > 0) {for ($i = $gap; $i < $n; $i++) {$temp = $arr[$i];for ($j = $i-$gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {$arr[$j+$gap] = $arr[$j];}$arr[$j+$gap] = $temp;}$gap = floor($gap/2);}return $arr;}```8. 计数排序```function counting_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$maxVal = max($arr);$countArr = array_fill(0, $maxVal+1, 0);for ($i = 0; $i < $n; $i++) {$countArr[$arr[$i]]++;}for ($i = 1; $i < $maxVal+1; $i++) {$countArr[$i] += $countArr[$i-1];}$tmpArr = array();for ($i = $n-1; $i >= 0; $i--) {$tmpArr[$countArr[$arr[$i]]-1] = $arr[$i];$countArr[$arr[$i]]--;}for ($i = 0; $i < $n; $i++) {$arr[$i] = $tmpArr[$i];}return $arr;}```9. 桶排序```function bucket_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$maxVal = max($arr);$bucketSize = 10;$bucketCount = floor($maxVal / $bucketSize) + 1;$buckets = array();for ($i = 0; $i < $bucketCount; $i++) {$buckets[$i] = array();}for ($i = 0; $i < $n; $i++) {$index = floor($arr[$i] / $bucketSize);array_push($buckets[$index], $arr[$i]);}$newArr = array();for ($i = 0; $i < $bucketCount; $i++) {$bucketArr = $buckets[$i];$len = count($bucketArr);if ($len > 1) {sort($bucketArr);}for ($j = 0; $j < $len; $j++) {array_push($newArr, $bucketArr[$j]);}}return $newArr;}```以上就是使用PHP 实现的9个经典的排序算法。
Heapsort堆排序算法详解（Java实现）
Heapsort堆排序算法详解（Java实现）Heapsort (堆排序)是最经典的排序算法之⼀，在google或者百度中搜⼀下可以搜到很多⾮常详细的解析。
同样好的排序算法还有quicksort（快速排序）和merge sort（归并排序），选择对这个算法进⾏分析主要是因为它⽤到了⼀个⾮常有意思的算法技巧：数据结构 -堆。
⽽且堆排其实是⼀个看起来复杂其实并不复杂的排序算法，个⼈认为heapsort在机器学习中也有重要作⽤。
这⾥重新详解下关于Heapsort的⽅⽅⾯⾯，也是为了⾃⼰巩固⼀下这⽅⾯知识，有可能和其他的⽂章有不同的⼊⼿点，如有错误，还请指出。
⽂中引⽤的referecne会再结尾标注。
p.s. 个⼈认为所谓详解是你在看相关wiki或者算法书看不懂的时候看通俗易懂的解释，不过最佳⽅案还是去看教授们的讲解，推荐reference[1]中的heapsort章节。
以上是废话，可以不看Section 1 - 简介Heapsort是⼀个comparison-based的排序算法（快排，归并，插⼊都是；counting sort不是），也是⼀种选择排序算法（selection sort），⼀个选择算法（selection algorithm）的定义是找到⼀个序列的k-th order statistic（统计学中的术语），直⽩的说就是找到⼀个list中第k-th⼩的元素。
以上都可以⼤不⽤懂，heapsort都理解了回来看⼀下是这回事就是了。
同样，插值排序也是⼀种选择排序算法。
Heapsort的时间复杂度在worst-case是O(nlgn)，average-case是O(nlgn)；空间复杂度在worst-case是O(1)，也就是说heapsort可以in-place 实现；heapsort不稳定。
以下顺便附上⼏种排序算法的时间复杂度⽐较（Θ−notation⽐O−notation更准确的定义了渐进分析（asymptotic analysis）的上下界限，详细了解可以⾃⾏google）：Table 1 - 四种排序算法的running time⽐较Algorithm Worst-case Average-case/expectedInsertion sort（插值排序）Θ(n2)Θ(n2)Merge sort（归并排序）Θ(nlgn)Θ(nlgn)Heapsort（堆排序）O(nlgn)O(nlgn)Quicksort（快速排序）Θ(n2)Θ(n2) (expected)*Additional Part - KNNheapsort在实践中的表现经常不如quicksort（尽管quicksort最差表现为Θ(n2)，但quicksort 99%情况下的runtime complexity为Θ(nlgn)），但heapsort的O(nlgn)的上限以及固定的空间使⽤经常被运作在嵌⼊式系统。
经典排序算法-堆排序heapsort
经典排序算法- 堆排序Heap sort
堆排序有点小复杂,分成三块
第一块,什么是堆,什么是最大堆
第二块,怎么将堆调整为最大堆,这部分是重点
第三块,堆排序介绍
第一块,什么是堆,什么是最大堆
什么是堆
这里的堆(二叉堆),指得不是堆栈的那个堆,而是一种数据构造。
堆可以视为一棵完全的二叉树,完全二叉树的一个“优秀〞的性质是,除了最底层之外,每一层都是满的,这使得堆可以利用数组来表示,每一个结点对应数组中的一个元素.
数组与堆之间的关系
二叉堆一般分为两种：最大堆和最小堆。
什么是最大堆
堆中每个父节点的元素值都大于等于其孩子结点〔假设存在〕,这样的堆就是一个最大堆
因此,最大堆中的最大元素值出如今根结点(堆顶)
节点与数组索引关系
对于给定的某个结点的下标i，可以很容易的计算出这个结点的父结点、孩子结点的下标，而且计算公式很漂亮很简约
第二块,怎么将堆调整为最大堆,这部分是重点
整个过程如以下图所示
在4,14,7这个小堆里边,父节点4小于左孩子14,所以两者交换
在4,2,8这个小堆里边,父节点4小于右孩子8,所以两者交换
上图展示了一趟调整的过程,这个过程递归实现,直到调整为最大堆为止第三块,堆排序介绍
堆排序就是把堆顶的最大数取出,
将剩余的堆继续调整为最大堆,详细过程在第二块有介绍,以递归实现
剩余部分调整为最大堆后,再次将堆顶的最大数取出,再将剩余部分调整为最大堆,这个过程持续到剩余数只有一个时完毕
下边三张图详细描绘了整个过程。
十大经典排序算法（动图演示）
⼗⼤经典排序算法（动图演⽰）0、算法概述0.1 算法分类⼗种常见排序算法可以分为两⼤类：⽐较类排序：通过⽐较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为⾮线性时间⽐较类排序。
⾮⽐较类排序：不通过⽐较来决定元素间的相对次序，它可以突破基于⽐较排序的时间下界，以线性时间运⾏，因此也称为线性时间⾮⽐较类排序。
0.2 算法复杂度0.3 相关概念稳定：如果a原本在b前⾯，⽽a=b，排序之后a仍然在b的前⾯。
不稳定：如果a原本在b的前⾯，⽽a=b，排序之后 a 可能会出现在 b 的后⾯。
时间复杂度：对排序数据的总的操作次数。
反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机内执⾏时所需存储空间的度量，它也是数据规模n的函数。
1、冒泡排序（Bubble Sort）冒泡排序是⼀种简单的排序算法。
它重复地⾛访过要排序的数列，⼀次⽐较两个元素，如果它们的顺序错误就把它们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述⽐较相邻的元素。
如果第⼀个⽐第⼆个⼤，就交换它们两个；对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对，这样在最后的元素应该会是最⼤的数；针对所有的元素重复以上的步骤，除了最后⼀个；重复步骤1~3，直到排序完成。
1.2 动图演⽰1.3 代码实现function bubbleSort(arr) {var len = arr.length;for (var i = 0; i < len - 1; i++) {for (var j = 0; j < len - 1 - i; j++) {if (arr[j] > arr[j+1]) { // 相邻元素两两对⽐var temp = arr[j+1]; // 元素交换arr[j+1] = arr[j];arr[j] = temp;}}}return arr;}2、选择排序（Selection Sort）选择排序(Selection-sort)是⼀种简单直观的排序算法。
排序算法之堆排序（Heapsort）解析
排序算法之堆排序（Heapsort）解析⼀.堆排序的优缺点（pros and cons）（还是简单的说说这个，毕竟没有必要浪费时间去理解⼀个糟糕的的算法）优点：1. 堆排序的效率与快排、归并相同，都达到了基于⽐较的排序算法效率的峰值（时间复杂度为O(nlogn)）2. 除了⾼效之外，最⼤的亮点就是只需要O(1)的辅助空间了，既最⾼效率⼜最节省空间，只此⼀家了3. 堆排序效率相对稳定，不像快排在最坏情况下时间复杂度会变成O(n^2)），所以⽆论待排序序列是否有序，堆排序的效率都是O(nlogn)不变（注意这⾥的稳定特指平均时间复杂度=最坏时间复杂度，不是那个“稳定”，因为堆排序本⾝是不稳定的）缺点：（从上⾯看，堆排序⼏乎是完美的，那么为什么最常⽤的内部排序算法是快排⽽不是堆排序呢？）1. 最⼤的也是唯⼀的缺点就是——堆的维护问题，实际场景中的数据是频繁发⽣变动的，⽽对于待排序序列的每次更新（增，删，改），我们都要重新做⼀遍堆的维护，以保证其特性，这在⼤多数情况下都是没有必要的。
（所以快排成为了实际应⽤中的⽼⼤，⽽堆排序只能在算法书⾥⾯顶着光环，当然这么说有些过分了，当数据更新不很频繁的时候，当然堆排序更好些...）⼆.内部原理⾸先要知道堆排序的步骤：1. 构造初始堆，即根据待排序序列构造第⼀个⼤根堆或者⼩根堆（⼤根堆⼩根堆是什么？这个不解释了，稻草垛知道吧..）2. ⾸尾交换，断尾重构，即对断尾后剩余部分重新构造⼤（⼩）根堆3. 重复第⼆步，直到⾸尾重叠，排序完成按⼩根堆排序结果是降序（或者说是⾮升序，不要在意这种细节..），按⼤根堆排序的结果是升序上⾯这句话乍看好像不对（⼩根堆中最⼩元素在堆顶，数组组堆顶元素就是a[0]，怎么会是降序？），不过不⽤质疑这句话的正确性，看了下⾯这⼏幅图就明⽩了：假设待排序序列是a[] = {7, 1, 6, 5, 3, 2, 4}，并且按⼤根堆⽅式完成排序第⼀步（构造初始堆）：{7, 5, 6, 1, 3, 2, 4}已经满⾜了⼤根堆，第⼀步完成第⼆步（⾸尾交换，断尾重构）：第三步（重复第⼆步，直⾄所有尾巴都断下来）：⽆图，眼睛画瞎了，mspaint实在不好⽤。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
经典排序算法- 堆排序Heap sort
堆排序有点小复杂,分成三块
第一块,什么是堆,什么是最大堆
第二块,怎么将堆调整为最大堆,这部分是重点
第三块,堆排序介绍
第一块,什么是堆,什么是最大堆
什么是堆
这里的堆(二叉堆),指得不是堆栈的那个堆,而是一种数据结构。
堆可以视为一棵完全的二叉树,完全二叉树的一个“优秀”的性质是,除了最底层之外,每一层都是满的,这使得堆可以利用数组来表示,每一个结点对应数组中的一个元素.
数组与堆之间的关系
二叉堆一般分为两种：最大堆和最小堆。
什么是最大堆
堆中每个父节点的元素值都大于等于其孩子结点（如果存在）,这样的堆就是一个最大堆
因此,最大堆中的最大元素值出现在根结点(堆顶)
节点与数组索引关系
对于给定的某个结点的下标i，可以很容易的计算出这个结点的父结点、孩子结点的下标，而且计算公式很漂亮很简约
第二块,怎么将堆调整为最大堆,这部分是重点
整个过程如下图所示
在4,14,7这个小堆里边,父节点4小于左孩子14,所以两者交换
在4,2,8这个小堆里边,父节点4小于右孩子8,所以两者交换
上图展示了一趟调整的过程,这个过程递归实现,直到调整为最大堆为止第三块,堆排序介绍
堆排序就是把堆顶的最大数取出,
将剩余的堆继续调整为最大堆,具体过程在第二块有介绍,以递归实现
剩余部分调整为最大堆后,再次将堆顶的最大数取出,再将剩余部分调整为最大堆,这个过程持续到剩余数只有一个时结束
下边三张图详细描述了整个过程。