14堆排序

八大排序算法排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

我们这里说说八大排序就是内部排序。

基本思想:将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。

即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

直接插入排序示例：如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。

所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

算法的实现：1.void print(int a[], int n ,int i){2. cout<<i <<":";3.for(int j= 0; j<8; j++){4. cout<<a[j] <<" ";5. }6. cout<<endl;7.}8.9.10.void InsertSort(int a[], int n)11.{12.for(int i= 1; i<n; i++){13.if(a[i] < a[i-1]){ //若第i个元素大于i-1元素，直接插入。

小于的话，移动有序表后插入14.int j= i-1;15.int x = a[i]; //复制为哨兵，即存储待排序元素16. a[i] = a[i-1]; //先后移一个元素17.while(x < a[j]){ //查找在有序表的插入位置18. a[j+1] = a[j];19. j--; //元素后移20. }21. a[j+1] = x; //插入到正确位置22. }23. print(a,n,i); //打印每趟排序的结果24. }25.26.}27.28.int main(){29.int a[8] = {3,1,5,7,2,4,9,6};30. InsertSort(a,8);31. print(a,8,8);32.}效率：时间复杂度：O（n^2）.其他的插入排序有二分插入排序，2-路插入排序。

第十章综合题1.什么是内排序? 什么是外排序? 什么排序方法是稳定的? 什么排序方法是不稳定的?2.设待排序的关键字序列为(15, 21, 6, 30, 23, 6′, 20, 17), 试分别写出使用以下排序方法每趟排序后的结果。

并说明做了多少次比较。

(1) 直接插入排序(2) 希尔排序(增量为5,2,1) (3) 起泡排序(4) 快速排序(5) 直接选择排序(6) 锦标赛排序(7) 堆排序(8) 二路归并排序(9) 基数排序3.在起泡排序过程中，什么情况下关键字会朝向与排序相反的方向移动，试举例说明。

在快速排序过程中有这种现象吗？4.快速排序在什么情况下所需关键字的比较次数最多？此时关键字比较次数应为多少？5.用直接插入排序方法对序列(94,32,40,90,80,46,21,69)进行排序（由小到大），试写出排序的过程。

6.已知初始序列为(125 ，11， 22， 34， 15， 44， 76， 66， 100， 8 ，14， 20， 2，5， 1)，写出采用希尔排序算法排序的每一趟的结果（增量为5，3，1）。

7.写出对初始序列(50,72,43,85,75,20,35，45，65，30)进行直接选择排序的过程。

8.若用冒泡排序对关键字序列(18,16,14,12,10,8),进行从小到大的排序，所需进行的关键字比较次数是多少。

9.给出关键字序列(27，18，21，77，26，45，66，34)，试写出快速排序过程。

10.无序序列为(10，2，13，15，12，14)，用堆排序方法从小到大排序，画出堆排序的初态、建堆和重建堆的过程。

11.写出对序列(28，16，32，12，60，2，5，72)进行2路归并排序的过程。

12.给出如下关键字序列(321，156，057，046，028，007，331，033，034，063)，试按链式基数排序方法，列出每一趟分配和收集的过程。

13.若参加锦标赛排序的关键字有11个，为了完成排序，至少需要多少次关键字比较？14.手工跟踪对以下各序列进行堆排序的过程。

数据结构复习题及答案数据结构习题一、名词解释1.数据、数据元素、数据项、数据结构、数据的逻辑结构、数据物理结构、顺序存储、链式存储、算法、时间复杂度、空间复杂度。

2.线性表、顺序表、单链表、双向链表、循环链表、双向循环链表、三个概念的区别：头指针、头结点、首元结点(第1个元素结点)。

3.栈（顺序栈、链栈）、队列（顺序队、链队）、循环队列、递归、稀疏矩阵、三元组。

4.树、叶子结点、结点的度、树的度、树的高(深)度、二叉树、遍历、满二叉树、完全二叉树、哈夫曼树、WPL、哈夫曼编码。

5.图（有向、无向）、网、边、弧、度、入度、出度、完全图（有向、无向）、（强）连通图（分量）、（最小）生成树、邻接矩阵、邻接表、DFS、BFS。

6.查找表、关键字、静态查找、动态查找、ASL、顺序查找、折半查找、分块查找、二叉排序树。

7、排序、内（外）排序、稳定性、插入（直接、希尔），交换（起泡、快速），选择（直接、堆），2路归并。

一、填空题1.数据结构是研究数据的_逻辑结构__和___物理结构__，并在这种结构上定义相关的运算，设计实现这些运算的算法，分析算法的效率。

算法的效率包括时间和空间两个方面，分别称为___时间复杂度____和__空间复杂度___。

2.数据的基本单元是__数据元素__，数据的最小单元是__数据项_。

3.算法是对特定问题求解___步骤___的一种描述，是指令的有限序列。

4.一个算法的时间复杂度为(3n3+2n—7)，其数量级表示为O（n3）_。

5.一个算法具有5个特性：确定性、可行性、有穷性、输入和输出。

6.算法机能的阐发和怀抱，能够从算法的工夫庞大度和空间庞大度来评判算法的好坏。

7.数据的逻辑布局包孕调集布局、线性布局、树形布局和图型布局四品种型。

8.数据布局在计较机中的表示称为数据的物理布局，它能够采用__按次存储___或__链式存储_两种存储方法。

9.线性表有两种存储布局，划分为按次存储和链式存储。

关于堆排序、归并排序、快速排序的⽐较时间复杂度：堆排序归并排序快速排序最坏时间 O(nlogn) O(nlogn) O(n^2)最好时间 O(nlogn) O(nlogn) O(nlogn)平均时间 O(nlogn) O(nlogn) O(nlogn)辅助空间 O(1) O(n) O(logn)～O(n)从时间复杂度看堆排序最好有⼈说代码实现后，数据量⾜够⼤的时候，快速排序的时间确实是⽐堆排序短解释是，对于数组，快速排序每下⼀次寻址都是紧挨当前地址的，⽽堆排序的下⼀次寻址和当前地址的距离⽐较长。

⽹友解答：1#4种⾮平⽅级的排序：希尔排序，堆排序，归并排序，快速排序我测试的平均排序时间：数据是随机整数，时间单位是秒数据规模快速排序归并排序希尔排序堆排序1000万 0.75 1.22 1.77 3.575000万 3.78 6.29 9.48 26.541亿 7.65 13.06 18.79 61.31堆排序是最差的。

这是算法硬伤，没办法的。

因为每次取⼀个最⼤值和堆底部的数据（记为X）交换，重新筛选堆，把堆顶的X调整到位，有很⼤可能是依旧调整到堆的底部（堆的底部X显然是⽐较⼩的数，才会在底部），然后再次和堆顶最⼤值交换，再调整下来。

从上⾯看出，堆排序做了许多⽆⽤功。

⾄于快速排序为啥⽐归并排序快，我说不清楚。

2#算法复杂度⼀样只是说明随着数据量的增加，算法时间代价增长的趋势相同，并不是执⾏的时间就⼀样，这⾥⾯有很多常量参数的差别，即使是同样的算法，不同的⼈写的代码，不同的应⽤场景下执⾏时间也可能差别很⼤。

快排的最坏时间虽然复杂度⾼，但是在统计意义上，这种数据出现的概率极⼩，⽽堆排序过程⾥的交换跟快排过程⾥的交换虽然都是常量时间，但是常量时间差很多。

3#请问你的快快速排序是怎么写的，我写的快速排序，当测试数组⼤于5000的时候就栈溢出了。

其他的⼏个排序都对着，不过他们呢没有⽤栈。

这是快速排序的代码，win7 32位，vs2010.1int FindPos(double *p,int low,int high)2 {3double val = p[low];4while (low<high)5 {6while(low<high&&p[high]>=val)7 high--;8 p[low]=p[high];9while(low<high&&p[low]<val)10 low++;11 p[high]=p[low];12 }13 p[low]=val;14return low;15 }16void QuickSort(double *a,int low,int high)17 {18if (!a||high<low)19return;2021if (low<high)22 {23int pos=FindPos(a,low,high);24 QuickSort(a,low,pos-1);25 QuickSort(a,pos+1,high);26 }27 }……7#谁说的快排好啊？我⼀般都⽤堆的，我认为堆好。

冒泡排序（Bubble sort）原理冒泡排序是一种简单的排序算法。

它重复访问要排序的数列，每一次比较两个元素，如果前一个大于后一个元素，则交换数据。

那么在一次全部访问过程中，最大的元素就’浮’动到数列的最后。

然后重复进行方法，知道再没有数据交换，也就是数列已经排序完成。

步骤1.比较相邻的元素。

如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。

这步做完后，最后的元素会是最大的数。

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

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

实现void BubbleSort(int arr[], int n) {int i, j;i = n;bool flag = true;while (flag) {flag = false;for (j = 1; j < i; j++) {if (arr[j-1] > arr[j]) {swap(arr[j-1],arr[j]);flag = true;}}i--;}}在上面的代码中加入了一个flag来标记是否有数据交换，如果在排序过程中没发生数据交换，则表示已经排列好了，后面就不需要在遍历了。

冒泡排序算是最简单的排序算法了，但毕竟是一种效率低下的排序算法，再数据量不大的情况下可以使用。

插入排序（Insertion sort）原理插入排序是一种直观的排序算法。

它通过构建有序数列，对未排序的数据，在已排序的数列中从后往前扫描，找到相应的位置插入。

在排序的实现上，从后向前的扫描过程中，需要反复把已排序的元素逐步向后移动，为要插入的元素留空间。

步骤1.从第一个元素开始，该元素可以认为已经被排序2.取出下一个元素，在已经排序的元素序列中从后向前扫描3.如果该元素（已排序）大于新元素，将该元素移到下一位置4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置5.将新元素插入到该位置后6.重复步骤2~5实现void InsertSort(int arr[], int n) {int i, j;for (i = 1; i < n; i++) {if (arr[i] < arr[i-1]) {int temp = arr[i];for (j = i - 1; j >= 0 && arr[j] > temp; j--){arr[j+1] = arr[j];}arr[j+1] = temp;}}}插入排序不适合对于数据了比较大的排序应用。

堆排序算法并行化的基本想法引言在计算机科学中，排序是一项基本操作，堆排序算法是一种高效的排序算法之一。

然而，随着计算机硬件的不断发展，越来越多的并行计算资源变得可用。

为了充分利用这些资源，人们开始研究如何将排序算法并行化，以提高排序的效率。

本文将探讨堆排序算法的并行化方法及其基本思想。

堆排序算法简介堆排序算法是一种基于数据结构“堆”的排序算法。

它的基本思想是将待排序的序列构建成一个最大堆（或最小堆），然后不断地将堆顶元素（最大或最小元素）与堆底元素交换，并调整堆，使得剩余元素重新构建成一个堆。

重复这个过程，直到所有元素都被排序完成。

堆排序算法具有如下特点： - 时间复杂度为O(nlogn)，其中n是待排序序列的长度 - 空间复杂度为O(1) - 是一种不稳定的排序算法堆排序算法串行实现在开始讨论并行化的堆排序算法之前，我们首先了解一下串行实现的基本思路。

1. 创建最大堆给定一个待排序序列，首先需要将其构建成一个最大堆。

具体而言，调用Build-Max-Heap函数，它会从最后一个非叶子节点开始，依次将每个子树调整为最大堆。

2. 堆排序一旦构建了最大堆，堆顶元素即为最大值。

将堆顶元素与数组最后一个元素交换，并将堆的大小减1。

然后，调用Max-Heapify函数将剩余元素重新构建成一个最大堆。

重复这个过程，直到堆的大小为1，即所有元素都被排序完成。

堆排序算法并行化的基本想法堆排序算法的串行实现已经足够高效，但在处理大规模数据时，仍然可以进一步提高其性能。

为了实现并行化，我们可以利用多线程或并行处理器同时对多个子树进行排序。

1. 多线程并行化一种实现并行化的方法是利用多线程。

我们可以将整个待排序序列划分为若干子序列，每个子序列由一个线程来处理。

每个线程进行堆排序算法的串行实现，即构建最大堆和堆排序两个主要步骤。

随着每个线程的完成，我们可以将各个子序列的已排序部分进行合并，从而得到最终的有序序列。

2. 并行处理器并行化另一种实现并行化的方法是利用并行处理器，如GPU（图形处理器）或FPGA（现场可编程门阵列）。

堆排序1 什么是堆首先堆是一种数据结构，是一棵完全二叉树且满足性质：所有非叶子结点的值均不大于或均不小于其左、右孩子结点的值，如下是一个堆得示例：9>8,9>5;8>3,8>1;5>2 由此发现非叶子结点的值均不小于左右孩子结点的值，所以这是个大顶堆，即堆顶的值是这个堆中最大的一个。

这个堆可以看成是一个一维数组A[6]={9,8,5,3,1,2}，那么相应的这个数组需满足性质：A[i]<=A[2*i] && A[i]<=A[2*i+1] 。

其中A[i]对应堆中的非叶子结点，A[2*i]和A[2*i+1]对应于左右孩子结点。

并且最后一非叶子结点下标为[n/2]向下取整。

为什么是[n/2]向下取整呢？在这里我简单的说明一下：设n1表示完全二叉树中有一个孩子的结点，n2表示表示完全二叉树中有两个孩子的结点，d表示非叶子结点的个数，那么总的结点个数：n=n1+2*n2+1。

（1）当n为奇数时，n1=0，n2=(n-1)/2，d=n2+n1=(n-1)/2（2）当n为偶数时，n1=1，n2=n/2-1，d=n2+n1=n/2由此可以看出d=[n/2]向下取整.2 筛选法调整堆（1）引出：现给定一个大顶堆：即：A[6]={9,8,5,3,1,2}，如果我们稍做破坏，把9跟2互换，同时把a[6]这个结点从堆中去掉，于是得到下面这个完全二叉树：A[5]={2,8,5,3,1} 显然它不是一个堆，那我们怎么把它调整为一个堆呢？首先观察，我们只是改变了根结点的值，所以根结点左、右子树均是大顶堆。

其次思考，既然是根结点可能破坏了堆的性质，那我们就可以把根结点往下沉，让最大值向上浮，即比较根结点和左、右孩子的值，若根结点的值不小于孩子结点的值，说明根结点并没有破坏堆的性质，不用调整；若根结点的值小于左右孩子结点中的任意一个值，则根结点与孩子结点中较大的一个互换，互换之后又可能破坏了左或右子树的堆性质，于是要对子树进行上述调整。

计算机常见的32种算法
1.冒泡排序算法
2.选择排序算法
3.插入排序算法
4.希尔排序算法
5.归并排序算法
6.快速排序算法
7.堆排序算法
8.计数排序算法
9.桶排序算法
10.基数排序算法
11.贪心算法
12.动态规划算法
13.分治算法
14.回溯算法
15.图的深度优先算法（DFS）
16.图的广度优先算法（BFS）
17. Kruskal算法（最小生成树）
18. Prim算法（最小生成树）
19. Floyd-Warshall算法（最短路径）
20. Dijkstra算法（最短路径）
21.拓扑排序算法
22. 找出最大子数组的算法（Kadane算法）
23.最长公共子序列算法
24.最长递增子序列算法
25.最长回文子串算法
26.哈夫曼编码算法
27. Rabin-Karp算法（字符串匹配）
28. Boyer-Moore算法（字符串匹配）
29.KMP算法（字符串匹配）
30.后缀数组算法
31.基于哈希表的查找算法
32.基于二分查找的查找算法
需要注意的是，以上列举的只是计算机中常见的算法之一，实际上还存在着很多其他的算法。

每种算法都有其特定的应用场景和解决问题的方法。

对于每种算法的原理和具体实现细节，可以进一步深入学习和研究。

一插入排序1.1 直接插入排序基本思想：每次将一个待排序额记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序。

图解：代码实现：[cpp]view plaincopy1.//直接顺序排序2.void InsertSort(int r[],int n)3.{4.for(int i=2;i<n;i++)5.{6.r[0]=r[i];//设置哨兵7.for(int j=i-1;r[0]<r[j];j--)//寻找插入位置8.r[j+1]=r[j];//记录后移9.r[j+1]=r[0];10.}11.for(int k=1;k<n;k++)12.cout<<r[k]<<"";13.cout<<"\n";14.}1.2 希尔排序基本思想是：先将整个待排序记录序列分割成若干个子序列，在在序列内分别进行直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。

图解：代码实现：[cpp]view plaincopy1.<spanstyle="font-size:14px;">//希尔排序2.void ShellSort(int r[],int n)3.{4.int i;5.int d;6.int j;7.for(d=n/2;d>=1;d=d/2)//以增量为d进行直接插入排序8.{9.for(i=d+1;i<n;i++)10.{11.r[0]=r[i];//暂存被插入记录12.for(j=i-d;j>0&&r[0]<r[j];j=j-d)13.r[j+d]=r[j];//记录后移d个位置14.r[j+d]=r[0];15.}16.}17.for(i=1;i<n;i++)18.cout<<r[i]<<"";19.cout<<"\n";20.}</span>二交换排序2.1 起泡排序起泡排序是交换排序中最简单的排序方法，其基本思想是：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。

分类：1）插入排序（直接插入排序、希尔排序）2）交换排序（冒泡排序、快速排序）3）选择排序（直接选择排序、堆排序）4）归并排序5）分配排序（基数排序）所需辅助空间最多：归并排序所需辅助空间最少：堆排序平均速度最快：快速排序不稳定：快速排序，希尔排序，堆排序。

先来看看8种排序之间的关系：1.直接插入排序（1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。

如此反复循环，直到全部排好顺序。

（2）实例（3）用java实现12345678911121314151617181920package com.njue;publicclass insertSort {public insertSort(){inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,2 5,53,51};int temp=0;for(int i=1;i<a.length;i++){int j=i-1;temp=a[i];for(;j>=0&&temp<a[j];j--){a[j+1]=a[j]; //将大于temp的值整体后移一个单位}a[j+1]=temp;}for(int i=0;i<a.length;i++){System.out.println(a[i]);}2. 希尔排序（最小增量排序）（1）基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差 d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。

当增量减到1时，进行直接插入排序后，排序完成。

（2）实例：（3）用java实现123456789101112131415161718192122232425262728293031publicclass shellSort { publicshellSort(){int a[]={1,54,6,3,78,34,12,45,56,100}; double d1=a.length;int temp=0;while(true){d1= Math.ceil(d1/2);int d=(int) d1;for(int x=0;x<d;x++){for(int i=x+d;i<a.length;i+=d){int j=i-d;temp=a[i];for(;j>=0&&temp<a[j];j-=d){a[j+d]=a[j];}a[j+d]=temp;}}if(d==1){break;}for(int i=0;i<a.length;i++){System.out.println(a[i]);}}3.简单选择排序（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

堆排序算法详解1、堆排序概述堆排序(Heapsort)是指利⽤堆积树（堆）这种数据结构所设计的⼀种排序算法，它是选择排序的⼀种。

可以利⽤数组的特点快速定位指定索引的元素。

堆分为⼤根堆和⼩根堆，是完全⼆叉树。

⼤根堆的要求是每个节点的值都不⼤于其⽗节点的值，即A[PARENT[i]] >= A[i]。

在数组的⾮降序排序中，需要使⽤的就是⼤根堆，因为根据⼤根堆的要求可知，最⼤的值⼀定在堆顶。

2、堆排序思想（⼤根堆）1）先将初始⽂件Array[1...n]建成⼀个⼤根堆，此堆为初始的⽆序区。

2）再将关键字最⼤的记录Array[1]（即堆顶）和⽆序区的最后⼀个记录Array[n]交换，由此得到新的⽆序区Array[1..n-1]和有序区Array[n]，且满⾜Array[1..n-1].keys≤Array[n].key。

3）由于交换后新的根R[1]可能违反堆性质，故应将当前⽆序区R[1..n-1]调整为堆。

然后再次将R[1..n-1]中关键字最⼤的记录R[1]和该区间的最后⼀个记录R[n-1]交换，由此得到新的⽆序区R[1..n-2]和有序区R[n-1..n]，且仍满⾜关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

这样直到⽆序区中剩余⼀个元素为⽌。

3、堆排序的基本操作1）建堆，建堆是不断调整堆的过程，从len/2处开始调整，⼀直到第⼀个节点，此处len是堆中元素的个数。

建堆的过程是线性的过程，从len/2到0处⼀直调⽤调整堆的过程，相当于o(h1)+o(h2)…+o(hlen/2) 其中h表⽰节点的深度，len/2表⽰节点的个数，这是⼀个求和的过程，结果是线性的O(n)。

2）调整堆：调整堆在构建堆的过程中会⽤到，⽽且在堆排序过程中也会⽤到。

利⽤的思想是⽐较节点i和它的孩⼦节点left(i),right(i)，选出三者最⼤者，如果最⼤值不是节点i⽽是它的⼀个孩⼦节点，那边交互节点i和该节点，然后再调⽤调整堆过程，这是⼀个递归的过程。

go实现堆排序、快速排序、桶排序算法⼀. 堆排序 堆排序是利⽤堆这种数据结构⽽设计的⼀种排序算法。

以⼤堆为例利⽤堆顶记录的是最⼤关键字这⼀特性，每⼀轮取堆顶元素放⼊有序区，就类似选择排序每⼀轮选择⼀个最⼤值放⼊有序区，可以把堆排序看成是选择排序的改进。

它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

⾸先简单了解下堆结构。

堆 堆是⼀棵完全⼆叉树：每个结点的值都⼤于或等于其左右孩⼦结点的值，称为⼤顶堆；或者每个结点的值都⼩于或等于其左右孩⼦结点的值，称为⼩顶堆。

如下图：对堆中的结点按层进⾏编号，将这种逻辑结构映射到数组中：由于它是⼀颗完全⼆叉树，所以满⾜序号leftchild = parent * 2 + 1;rightchild = parent * 2 + 2;这样的特性，利⽤这⼀特性，每次将parent与child进⾏⽐较然后向下调整元素的位置。

实现堆排序1. 将初始待排序关键字序列(R0,R1,R2....Rn)构建成⼤顶堆，此堆为初始的⽆序区；初始堆满⾜⼤顶堆性质，但是元素⽆序。

2. 依次将将堆顶元素R[0]与最后⼀个元素R[n]交换，此时得到新的⽆序区(R0,R1,R2,......Rn-1)和新的有序区(Rn)；3. 交换后进⾏向下调整⽆序区，使其满⾜⼤顶堆性质。

4. 循环执⾏ 2.3 步骤直到遍历完数组。

1 func HeapSort(arr []int) {2 arrLen := len(arr)3for i := (arrLen-2)/2; i >= 0; i-- {4 arrJustDown(arr, i, arrLen)5 }6end := arrLen - 17for end != 0 {8 arr[0], arr[end] = arr[end], arr[0]9 arrJustDown(arr, 0, end)10end--11 }12 fmt.Println(arr)13 }14 func arrJustDown(arr []int, root, n int) {15 parent := root16 child := parent * 2 + 117for child < n {18if child + 1 < n && arr[child + 1] > arr[child] {19 child++20 }21if arr[child] > arr[parent] {22 arr[child], arr[parent] = arr[parent], arr[child]23 parent = child24 child = parent * 2 + 125 } else {26break27 }28 }29 } 建堆和每次向下调整的时间复杂度都是long2N ,所以整个数组处理完后，需要执⾏Nlong2N遍，调整过程中，最后⼀个元素和堆顶元素交换后需要向下调整，所以不保证相同⼤⼩元素的位置不变，它是不稳定排序。