C语言实现----堆排序

一、堆排序介绍

堆排序（ Heap Sort ）是指利用堆这种数据结构所设计的一种排序算法。

因此，学习堆排序之前，有必要了解堆！若读者不熟悉堆，建议先了解堆，然后再来学习本章。

我们知道，堆分为"最大堆"和"最小堆"。最大堆通常被用来进行"升序"排序，而最小堆通常被用来进行"降序"排序。

鉴于最大堆和最小堆是对称关系，理解其中一种即可。本文将对最大堆实现的升序排序进行详细说明。

看本文之前可以看看--->>B站视频讲解

最大堆进行升序排序的基本思想：

①初始化堆：将数列 a [1... n ］构造成最大堆。

②交换数据：将 a [1］和 a [n］交换，使 a [n］是 a [1.. n］中的最大值；然后将 a [1.. n -1］重新调整为最大堆。接着，将 a [1］和 a [n -1］交换，使 a[ n -1］是 a[1..n-1］中的最大值；然后将 a [1..n -2］重新调整为最大堆。依次类推，直到整个数列都是有序的。

下面，通过图文来解析堆排序的实现过程。注意实现中用到了"数组实现的二叉堆的性质"。

在第一个元素的索引为0的情形中：

性质一：索引为的左孩子的索引是（2* i +1);

性质二：索引为的右孩子的索引是（2* i +2);

性质三：索引为的父结点的索引是 floor((i-1)/2);     floor()为向下取整。

 例如，对于最大堆{110,100,90,40,80,20,60,10,30,50,70} 而言：索引为0的左孩子的索引是1；索引为0的右孩子的索引是2；索引为8的父节点是3.

二、堆排序图文说明

1. 堆排序（升序）代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

void swap(int* a, int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

// （最大）堆的向下调整算法
// 注：数组实现的堆中，第N个节点的左孩子的索引值是（2N+1），右孩子的索引是（2N+2）。
// 其中，N为数组下标索引值，如数组中第1个数对应的N为0。
// 
// 参数说明
// a -- 待排序的数组
// start -- 被下调节点的起始位置（一般为0，表示从第一个开始）
// end -- 截止范围（一般为数组中最后一个元素的索引）

void maxheap_sort(int a[], int start,int end) {
	int c = start; // 当前（current）节点的位置
	int l = 2 * c + 1; // 左（left）孩子的位置
	int tmp = a[c]; // 当前（current）节点的大小
	for (; l <= end; c = l, l = 2 * l + 1) {
		// “l”是左孩子，“l+1”是右孩子
		if (l < end && a[l] < a[l + 1]) {
			l++; // 左右两个孩子中选择较大者，即m_heap[l+1]
		}
		if (tmp >= a[l]) {
			break; // 调整结束
		}
		else {// 交换值
			a[c] = a[l];
			a[l] = tmp;
		}
	}
}

// 堆排序（从小到大）

// 参数说明：
// a -- 待排序的数组
// n -- 数组的长度

void heap_sort_asc(int a[], int n) {
	int i;
	// 从（n/2-1）--> 0 逐次遍历。遍历之后，得到的数组实际上是一个（最大）二叉堆
	for (i = n / 2 - 1; i >= 0; i--) {
		maxheap_sort(a, i, n - 1);
	}
	// 从最后一个元素开始对序列进行调整，不断地缩小调整的范围直到第一个元素
	for (i = n - 1; i > 0; i--) {
		// 交换a[0]和a[i]。交换后，a[i]是a[0..i]中最大的。
		swap(&a[0], &a[i]);
		// 调整a[0..i-1]，使得a[0..i-1]仍然是一个最大堆。
		// 即，保证a[i-1]是a[0..i-1]中的最大值。
		maxheap_sort(a, 0, i - 1);
	}
}



int main() {
	int arr[] = { 9,5,1,6,2,3,0,4,8,7 };
	heap_sort_asc(arr, 10);
	for (int i = 0; i < 10; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}

heap_sort_asc(a,n)的作用是：对数组a进行升序排序；其中，a是数组，n是数组长度。

heap_sort_asc(a,n) 的操作分为两部分：初始化堆和交换数据。

maxheap_down(a, start, end)是最大堆向下调整算法。

下面演示heap_sort_asc(a,n) 对 a={20,30,90,40,70,110,60,10,100,50,80}, n = 11 进行堆排序过程。下面是数据 a 对应的初始化结构：

 2. 初始化堆

在堆排序算法中，首先要将待排序的数组转化为二叉堆。下面演示将数组 {20,30,90,40,70,110,60,10,100,50,80}转换为最大堆 {110,100,90,40,80,20,60,10,30,50,70}的步骤。

i = 11/2 - 1，即i = 4

 上面是maxheep_down(a,4,9)调整过程。

maxheap_down(a,4,9)的作用是将a[4..9]进行下调；a[4] 的左孩子是a[9]，右孩子是 a[10]。调整时，选择左右孩子中较大的一个（即a[10]）和a[4]  交换。

i = 3

 上面是maxheap_down(a,3,9)调整过程。

maxheap_down(a,3,9)的作用是将 a[3..9]进行下调; a[3]的左孩子是 a[7], 右孩子是a[8]。调整时，选择左右孩子中较大的一个（即a[8]）和a[4] 交换。

i = 2

 上面是maxheap_down(a,2,9)调整过程。

maxheap_down(a,2,9)的作用是将 a[2..9]进行下调; a[2]的左孩子是 a[5], 右孩子是a[6]。调整时，选择左右孩子中较大的一个（即a[5]）和a[2] 交换。

i = 1

 上面是maxheap_down(a,1,9)调整过程。

maxheap_down(a,1,9)的作用是将 a[1..9]进行下调; a[1]的左孩子是 a[3], 右孩子是a[4]。调整时，选择左右孩子中较大的一个（即a[3]）和a[1] 交换。交换之后，a[3] 为 30，它比它的右孩子a[8] 要大，接着，再将他们交换。

i = 0

上面是 maxheap _ down ( a ,0,9）调整过程。

maxheap _ down ( a ,0,9）的作用是将 a [0..9］进行下调； a [0] 的左孩子是 a [1]，右孩子是 a [2]。调整时，选择左右孩子中较大的一个（即 a [2]）和 a[0] 交换。交换之后， a [2］为20，它比它的左右孩子要大，选择较大的孩子（即左孩子）和 a [2］交换。

调整完毕，就得到了最大堆。此时，数组{20,30,90,40,70,110,60,10,100,50,80｝也就变成了{110,100,90,40,80,20,60,10,30,50,70}。

3. 交换数据

在将数组转换成最大堆之后，接着要进行交换数据，从而使数组成为一个真正的有序数组。

交换数据部分相对比较简单，下面仅仅给出将最大值放在数组末尾的示意图。

上面是当 n =10时，交换数据的示意图。

当 n =10时，首先交换 a [0］和 a [10]，使得 a [10］是 a [0...10］之间的最大值；然后，调整 a [0..9］使它称为最大堆。交换之后： a [10]是有序的！

当 n =9 时，首先交换 a [0］和 a [9]，使得 a [9］是 a [0...9］之间的最大值；然后，调整 a [0...8］使它称为最大堆。交换之后：a [9...10］是有序的！

依此类推，直到 a [0...10］是有序的。

三、堆排序的时间复杂度和稳定性

1. 堆排序的时间复杂度

堆排序的时间复杂度是 O ( N * IgN )。

假设被排序的数列中有 N 个数。遍历一趟的时间复杂度是 O ( N )，需要遍历多少次呢？堆排序是采用的二叉堆进行排序的，二叉堆就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是 Ig ( N +1)。最多是多少呢？由于二叉堆是完全二叉树，因此，它的深度最多也不会超过 Ig (2N)。因此，遍历一趟的时间复杂度是 O ( N )，而遍历次数介于 Ig ( N +1）和 lg (2N）之间；因此得出它的时间复杂度是O ( N * IgN )。

2. 堆排序的稳定性

堆排序是不稳定的算法，它不满足稳定算法的定义。它在交换数据的时候，是比较父结点和子节点之间的数据所以，即便是存在两个数值相等的兄弟节点，它们的相对顺序在排序也可能发生变化。

算法稳定性：假设在数列中存在 a[i]= a[j] ，若在排序之前， a [i]在 a[j] 前面并且排序之后， a [i］仍然在 a [ j ］前面。则这个排序算法是稳定的！