堆排序
高级排序方法
高级排序方法
高级排序方法包括快速排序、归并排序、堆排序和计数排序等。
1. 快速排序：通过选取一个基准元素，将数组分成两个部分，其中一部分的元素都小于基准元素，另一部分的元素都大于基准元素。
然后对这两部分分别递归进行快速排序，最后将结果合并起来。
快速排序的平均时间复杂度为O(nlogn)。
2. 归并排序：将数组不断分成两个部分，然后对每个部分进行排序，最后将两个有序部分合并起来。
归并排序的平均时间复杂度为O(nlogn)。
3. 堆排序：利用堆数据结构进行排序的方法。
将待排序数组构建成一个二叉堆，然后依次将堆顶元素取出，再调整堆，直到所有元素都取出。
堆排序的时间复杂度为O(nlogn)。
4. 计数排序：对于一定范围内的整数，统计每个元素出现的次数，然后按照元素的顺序输出。
计数排序的时间复杂度为
O(n+k)，其中n为元素个数，k为元素的范围。
这些高级排序方法在不同情况下具有不同的优势，选择合适的排序方法可以提高排序效率。
堆排序实例演示
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
数据结构
堆排序与斐波那契查找
•
斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点
对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数
小1，及n=F(k)-1;
•
• 开始将k值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1),比较结果
也分为三种：
1）相等，mid位置的元素即为所求
以把len设置成为全局变量
• • function buildMaxHeap(arr) { // 建立大顶堆 • len = arr.length; • for (var i = Math.floor(len/2); i >= 0; i--) { • heapify(arr, i); •} •}
• function heapify(arr, i) { // 堆调整
• var left = 2 * i + 1,
•
right = 2 * i + 2,
•
largest = i;
•
• if (left < len && arr[left] > arr[largest]) {
•
largest = left;
•}
•
• if (right < len && arr[right] > arr[largest]) {
这时，交换导致了子根[4,5,6]结构混乱， 继续调整，[4,5,6]中6最大，交换4和6。
步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。
然后继续调整堆，再将堆顶元素与末尾元素交换，得到第 二大元素。如此反复进行交换、重建、交换。
建立堆
• var len; // 因为声明的多个函数都需要数据长度，所
堆排序c语言代码
堆排序c语言代码/********************************************************** **************//* 堆排序c语言代码 *//********************************************************** **************/#include <stdio.h>#include <stdlib.h>/** 将一个完全二叉树变为大顶堆* 从最后一个非叶子节点开始调整*/void AdjustHeap(int a[], int start, int end){int tmp = a[start];for(int i=2*start+1; i<=end; i*=2){if(i < end && a[i] < a[i+1]){++i;}if(tmp >= a[i]) //tmp就是根节点，如果tmp的值大于子节点，那就不用调整{break;}a[start] = a[i]; //把子节点往上移动，替换它的父节点start = i; //更新start，以便继续向下筛选}a[start] = tmp; //把tmp放到最终的位置}/** 堆排序:* 初始建立大顶堆，然后把［0］位置上的数拿出来，* 放到最后，然后重新调整前面的大顶堆，* 这样子不断的重复调整和取出最大值就可以得到一个有序序列*/void HeapSort(int a[], int n){// step1: 先把数组建成大顶堆for(int i=(n-2)/2; i>=0; --i){AdjustHeap(a, i, n-1);}// step2: 取出根节点，和最后一个节点交换，然后剩下的重新调整成大顶堆for(int i=n-1; i>0; --i){int tmp = a[i];a[i] = a[0];a[0] = tmp;AdjustHeap(a, 0, i-1);}}int main(int argc, char*argv[]){int a[] = {7, 5, 19, 8, 4, 1, 20, 13, 16};int len = sizeof(a) / sizeof(int);HeapSort(a, len);//输出排序结果for(int i=0; i<len; ++i) {printf('%d,', a[i]);}printf('');return 0;}。
1234567堆排序比较次数详解
xxx堆排序比较次数详解在计算机科学领域，堆排序是一种基于堆数据结构的排序算法，它是一种非常高效的排序方法，尤其在大数据集上表现突出。
堆排序的关键在于利用堆的性质来实现排序过程，而其中一个重要的指标就是比较次数。
在本文中，我将对xxx堆排序的比较次数进行详细的解析，希望能够帮助大家更好地理解这一排序算法。
我们需要了解什么是堆排序。
堆排序是一种选择性排序，它利用了堆这种数据结构的特性来实现。
堆可以被看作一棵树，它满足两个性质：结构性和堆序性。
结构性是指堆是一个完全二叉树，而堆序性是指堆中任意节点的值都不大于（或不小于）其孩子节点的值。
根据堆的性质，我们可以利用堆来进行排序，这就是堆排序算法的基本思想。
在xxx堆排序中，比较次数是一个非常重要的指标。
比较次数可以用来衡量算法的效率和性能，它表示在排序过程中进行了多少次元素之间的比较操作。
对于堆排序来说，比较次数取决于待排序数据的特点以及具体的实现方式。
在最坏情况下，比较次数是一个与n相关的量级，其中n表示待排序数据的大小。
一般情况下，堆排序的比较次数大约为nlogn，这使得堆排序成为一种非常高效的排序算法。
在xxx堆排序的实现过程中，比较次数是如何计算的呢？在建立堆的过程中，需要进行n/2次比较，这是因为堆是一棵完全二叉树，而叶子节点不需要进行比较。
在堆排序的过程中，需要进行n-1次比较，这是因为每次将最大（或最小）的元素移出堆后，需要对剩余的元素进行调整，直到完成排序。
堆排序的比较次数可以用一个简单的公式表示：n/2 + (n-1) = 3n/2 - 2。
除了比较次数外，xxx堆排序还涉及到交换次数和空间复杂度等指标。
交换次数表示在排序过程中进行了多少次元素之间的交换操作，而空间复杂度表示算法在执行过程中所需的额外空间。
这些指标的综合考量可以帮助我们更全面地评估堆排序算法的性能和适用范围。
xxx堆排序的比较次数是一个非常重要的指标，它可以帮助我们评估算法的效率和性能。
[编程题]堆排序（数组与大顶堆的转换过程）
![[编程题]堆排序（数组与大顶堆的转换过程）](https://img.taocdn.com/s3/m/efcc56e06394dd88d0d233d4b14e852458fb397a.png)
[编程题]堆排序（数组与⼤顶堆的转换过程）[编程题] 堆排序（数组与⼤顶堆的转换过程）数组和树的关系题⽬信息如何把数组转换为⼆叉树呢？思路数组对应树的公式:数组⼀个节点的左孩⼦:2*i+1数组⼀个节点的右孩⼦:2*i+2某节点的⽗亲节点：(i-1)/2注意数组转为⼤顶堆思路思路：在每⼀个节点进⼊的时候，就会⽐较其与⽗节点的⼤⼩关系，调整树结构。
（这⾥即是交换数组中的元素），建⽴出了⼤顶堆的数组。
建⽴⼤顶堆的时间复杂度时间复杂度：O（nlogn）Java代码package Demo11_堆;import ng.reflect.Parameter;import java.util.Arrays;/*** @author jiyongjia* @create 2020/8/9 - 13:23* @descp:*/public class P3_堆排序 {public static void main(String[] args) {int[] arr = {10, 131,3,42,221,3,2,-1,0,-32, 40, 5, 2, 18};// heapify(arr,arr.length,0);// heap_build(arr);heapSort(arr);System.out.println(Arrays.toString(arr));}/*** 1 heapify操作（需要按照传⼊的i的⽗节点进⾏递归的heapify操作）* @param arr 数组* @param n 数组的个数* @param i 传⼊的⽗节点的索引号（如0）*/public static void heapify(int[] arr,int n,int i){//递归的出⼝if(i>=n){return;}int l = 2*i+1;int r = 2*i+2;int maxIndex = i;if(l<n && arr[l]>arr[maxIndex]){ //TODO:注意maxIndex = l;}if(r<n && arr[r]>arr[maxIndex]){maxIndex = r;}if(maxIndex != i){swap(arr,i,maxIndex);//只有不等才交换//递归处理heapify(arr,n,maxIndex);}}public static void swap(int[] arr,int i,int j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}/***2 使⽤heapify从最后⼀个⾮叶⼦节点往前遍历每个⽗节点，然后⽣成⼀个⼤顶堆* @param arr*/public static void heap_build(int[] arr){int n = arr.length;int lastNodeParent = (n-1-1)/2; //根据公式计算最后⼀个⾮叶⼦节点（即最后⼀个⽗节点）for (int i = lastNodeParent; i >=0 ; i--) {heapify(arr,arr.length,i); //倒着推的从下往上构建好堆}}//3 构建好堆之后，每次把堆顶的元素和最后⼀个元素交换，得到⼀个最⼤值放最后了public static void heapSort(int[] arr){heap_build(arr);//先构造出⼀个堆for(int i=arr.length-1;i>=0;i--){//经过交换，最⼤的堆顶到了最后⼀个元素的地⽅swap(arr,i,0);//下次heapfify就不考虑这个最后的这个堆即可heapify(arr,i,0); //从0开始heapify这个堆来调整堆。
关于堆排序、归并排序、快速排序的比较
关于堆排序、归并排序、快速排序的⽐较时间复杂度：堆排序归并排序快速排序最坏时间 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#谁说的快排好啊？我⼀般都⽤堆的，我认为堆好。
大量数据排序算法
大量数据排序算法随着信息技术的发展，数据量的快速增长已经成为常态。
在这个大数据时代，如何对大量数据进行高效的排序成为了一个重要的问题。
本文将介绍几种常见的大量数据排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序和堆排序。
一、冒泡排序冒泡排序是最简单的排序算法之一。
它的基本思想是通过相邻元素的比较和交换，将最大（或最小）的元素逐渐“冒泡”到序列的最右端（或最左端）。
具体实现时，从序列的第一个元素开始，依次比较相邻的两个元素，如果顺序不对则交换它们的位置。
重复这个过程，直到整个序列有序。
二、选择排序选择排序是一种简单直观的排序算法。
它的基本思想是每次从未排序的序列中选择最小（或最大）的元素，放到已排序序列的末尾（或开头）。
具体实现时，设定一个标记，表示已排序序列的最后一个位置，然后遍历未排序的序列，找到最小（或最大）的元素，与标记位置的元素交换位置。
重复这个过程，直到整个序列有序。
三、插入排序插入排序是一种简单直观的排序算法。
它的基本思想是将未排序的元素逐个插入到已排序序列中的适当位置，从而得到一个新的有序序列。
具体实现时，从第二个元素开始，依次将当前元素与已排序序列中的元素进行比较，找到合适的插入位置并将其插入。
重复这个过程，直到整个序列有序。
四、归并排序归并排序是一种稳定的排序算法。
它的基本思想是将待排序序列分成两个子序列，分别对两个子序列进行排序，然后将排好序的两个子序列合并成一个有序序列。
具体实现时，采用递归的方式，将序列不断地二分，直到序列长度为1，然后逐层合并有序序列，直到整个序列有序。
五、快速排序快速排序是一种常用的排序算法。
它的基本思想是通过一趟排序将待排序序列分割成独立的两部分，其中一部分的元素都比另一部分的元素小，然后对这两部分分别递归地进行排序。
具体实现时，选择一个基准元素，将序列分成两部分，左边的元素都比基准元素小，右边的元素都比基准元素大。
然后再分别对左右两部分进行递归排序，直到整个序列有序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算法与数据结构程设计报告一．设计题目：堆排序的算法二．运行环境：1、硬件：计算机2、软件：Microsoft Visual C++6.0三．目的和意义：目的：创建一个大堆，按从大到小顺序输出堆元素，实现堆排序。
意义：利用堆排序，即使在最坏情况下的时间复杂度也是O(nlog2n)，相对于快速排序来说，时间复杂度小，这是堆排序的最大优点，可用于对若干元素进行排序，加快排序速度。
四．算法设计的基本思想：堆排序算法设计基本思想：堆排序利用了大根堆堆顶记录的关键字最大这一特征，使得在当前无序区中选取最大关键字的记录变得简单。
先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区。
再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录r[n]交换，由此得到新的无序区r[1..n-1]和有序区r[n]，且满足r[1..n-1].keys≤r[n].key。
由于交换后新的根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：打印数组函数print()六．算法设计分析：性能分析：堆排序的时间主要由建立初始堆和不断重复建堆这两部分的时间开销构成,它们均是通过调用Heapify实现的。
其中：建立初始堆时，总共需进行的关键字比较次数≤ 4n =O(n) ;排序过程中进行n-1次重建堆所进行的总比较次数不超过下式：2*(└ log2(n-1) ┘+└ log2(n-2) ┘+…+ └ log22 ┘) < 2n └ log2n ┘=O(n log2n)因此堆排序总的时间复杂度是 O(n+ n log2n)= O(n log2n)。
堆排序在最坏情况下的时间复杂度也是O(nlog2n)，相对于快速排序来说，这是堆排序的最大优点。
另外，堆排序仅需一个记录大小供交换用的辅助空间。
由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录较少的文件，但对n较大的文件还是很有效的。
堆排序是就地排序，辅助空间为O(1)，它是不稳定的排序方法。
堆的描述：堆排序(HeapSort)是一树形选择排序。
堆是对基于数组的树的重要应用场合之一。
它是节点间具有层次次序关系的完全二叉树。
其中，父节点值大于或等于其孩子节点值的，叫“最大堆（maximum heap）”;父节点值小于或等于孩子节点值的，叫“最小堆（minimum heap）”.在最大堆中，根中的元素值最大；在最小堆中，根中的元素值最小。
堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大(或最小)的记录。
从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。
所以堆排序有两个函数组成。
一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
堆的存储特点：在这里，讨论作为顺序表存储的堆。
它是按某种次序将一系列数据以完全二叉树形式存放的一种表。
它要求堆中的节点的值都大于或等于其孩子节点的值。
按照这种存储方式，可知第i个元素的左右儿子分别是第2i和第2i+1个元素，而它的父亲节点是第i/2个元素。
由于父亲节点和儿子节点具有这样的顺序关系，所以可以方便地由父亲节点找到儿子节点，反之亦然。
可见，这种存储方式大大节省了存储空间，高效快速。
堆的相关操作：作为抽象表结构，堆允许增加和删除表项。
插入过程不用假定新表项占有一个特定的位置而只需维持堆顺序。
但是删除操作总是删去表中的最大项（根）。
堆可以用于那些客户程序想直接访问最大（小）元素的场合。
作为表，堆并不提供Find操作，而对表的直接访问是只读的。
所有的堆处理算法都有责任更新树和维持堆顺序。
1.建堆：数组具有对应的树表示形式。
一般情况下，树并不满足堆的条件。
通过重新排列元素，可以建立一棵“堆化”的树。
2.插入一个元素：新元素被加入到表中，随后树被更新以恢复堆次序。
例如，下面的步骤将15加入到表中。
3.删除一个元素：删除总是发生在根节点处。
用表中的最后一个元素来填补空缺位置，结果树被更新以恢复堆条件。
在堆实现时我们是采用数组来存储堆的完全二叉树表示，并且用一种有效的算法来保证对堆的所有操作不破坏堆的性质。
这种表示的主要问题在于数组的大小需要事先确定，这使得对堆的大小有了一个初始的限定。
在堆中数据增长到超过这个界限时虽然可以通过复制的方法建立更大的向量来存放堆，但整个向量的复制是不可避免的，这大大降低了操作效率。
为避免这个问题，可把二叉树的顺序存储改为二叉树的链表存储 .根据算法复杂性分析的结果。
Williams & Floyd在1964年提出的堆排序算法在最坏情况的时间复杂性为2 n log n + O(n)。
但在判定树的模型下，为n 个数排序的算法时间复杂性的下界为n log n + O(n)。
可见，Williams & Floyd 的算法或许可以改进。
其中在进入实质性排序的第i步，在把第i大元素（在堆顶）与当时处在第i大的目标位置的元素对调之后，总是让堆顶元素往下沉，可能直到叶子才完成局部（重新）堆化。
如果当时处在第i大的目标位置元素很小，则下沉过程中要做很多次的比较。
如果能把这个次数降下来，或许能对Williams & Floyd的算法作出效率上的显著改进。
顾训穰，诸宇章就是这样循着发现问题、提出问题、分析问题和解决问题的线索，通过让空缺结点一下下沉h/2达到改进的目的，于1994年在《软件学报》上发表他们的成果。
改进后的堆排序算法在最坏情况下的时间复杂性为n log n + n log log n + O(n)主项系数由2降为 1，与下界的主项系数同。
进一步，王晓东、傅清祥等还是沿着发现问题、提出问题、分析问题和解决问题的思路，发现顾训穰、诸宇章的算法可以通过让空缺结点下沉f(h)=h-logh (不是h/2) 改进其时间复杂性的次项，于1996年在《软件学报》上发表他们的成果。
进一步改进后的堆排序算法在最最坏情况下的时间复杂性为n log n + n α3(n) + O(n)其中，函数x=α3(y) 是3阶Ackerman函数y=A (x，3)的逆函数。
众多的反映表明以上的设计是可取的。
七．源代码：程序源代码如下：/*Name: heapsort2.cAuthor: huangxingDescription: 堆排序算法的过程演示Date: 30/11/2005Copyright:*/#include<stdio.h>#define N 6int k,j;/* 建堆函数 */void build(int *a,int i,int n){int tmp;k=i;j=2*k+1;while(j<=n){if(j<n && a[j]<a[j+1])j++;if(a[k]>=a[j])break;tmp=a[k];a[k]=a[j];a[j]=tmp;k=j;j=2*j+1;}}/* 打印数组函数 */void prnt(int *a,int n){int i;printf("\n");for(i=0;i<n;i++){printf("%3d",a[i]);}printf("\n");}/* 打印堆函数 */void prnthp(int *a,int b1,int b2){int size;int h=0,sum=0,item=1;int i,j,cnt,start,tmp;size=b2-b1+1;while(sum<=size){sum+=item;h++;item*=2;}item=1;cnt=0;start=b1;tmp=1;printf("\n--------------------------------------------\n"); printf(" 堆：\n");while(1){for(i=0;i<h;i++){for(j=0;j<h-i;j++)printf(" ");for(j=0;j<i+1;j++)printf(" ");for(j=0;j<tmp;j++){if(cnt>size-1)goto end;printf("%4d",a[cnt++]);}printf("\n");tmp*=2;}}end:printf("\n");return;}/* 打印已排序数组函数 */void prntar(int *a,int b2,int len){int i;printf(" 已排序：\n");for(i=0;i<b2;i++){printf(" ");}for(i=b2;i<=len;i++){printf("%3d",a[i]);}printf("\n");}main(){/* int a[]={-1,2,5,1,0,-3,-2,8,6}; */int a[50];int i;int tmp;int sum;int num;int len;printf(" 堆排序\n");printf("\n============================================\n"); printf("\n 请输入待排序数组个数,以回车结束：\n");scanf("%3d",&len);printf("\n 请输入待排序数组,以回车结束：\n");for(i=0;i<len;i++)scanf("%3d",&a[i]);tmp=1;sum=0;while(sum+tmp<=len){sum+=tmp;tmp*=2;}printf("\n============================================\n"); printf("\n 初始数组： \n");prnt(a,len);/* 建初始堆 */for(i=sum-1;i>=0;i--)build(a,i,len-1);prnthp(a,0,len-1);/* 改建堆 */for(i=0;i<len-1;i++){tmp=a[0];a[0]=a[len-1-i];a[len-1-i]=tmp;build(a,0,len-2-i);prnthp(a,0,len-2-i);prntar(a,len-1-i,len-1);}printf("\n--------------------------------------------\n");printf("\n 排序结果：\n");prnt(a,len);printf("\n============================================\n\n");getch();}八．程序调试过程分析：程序刚开始运行不了，错误达8处，于是本人就认真检查，居然发现有6处不是写错了符号就是少了括号，粗心之至。