十大基础应用算法及C++实现（二）----堆排序算法

堆排序算法利用了大根堆（或者小根堆，下同）的两个固有性质，即：

1.堆本身是一棵完全二叉树；

2.大根堆的根元素永远大于或者小于其子树的所有元素。

性质1给我们的主要结论为：设完全二叉树的元素编号为i（i∈[1,n],n为元素总数），如果i>n/2，则i这个元素一定是叶节点；否则i一定不是叶节点。证明过程可以用归纳法，比较简单。这个性质的主要用途是构建初始大根堆，基本原理是按照序号从大到小，对所有的非叶节点做堆调整（将子树调整成大根堆）。

性质2的主要用途是每次取出（删除）根节点，与序号最大的叶节点元素互换，然后剔除这个叶节点，剩下的树结构再重复以上操作，即每次都取出剩余堆的最大元素，直到最后一个元素。下面贴代码，代码继承了本人博客十大基础应用算法及C++实现（一）的相关代码，和快速排序算法以及冒泡法的效率作比较。

#include "stdafx.h"
#include <stdlib.h>
#include "ConsoleApplication1.h"
#include <iostream>
#include <time.h>
#define SIZE 100000
inline void swap(int&a, int&b)
{
	int temp = a;
	a = b;
	b = temp;
}

int main()
{

	using namespace std;
	double        dStartTime1;                //快速排序算法起始时间
	double        dEndTime1;
	double		  usetime1;
	double        dStartTime2;                //冒泡算法起始时间
	double        dEndTime2;
	double		  usetime2;
	double        dStartTime3;                //堆算法起始时间
	double        dEndTime3;
	double		  usetime3;
	int* all = new int[SIZE];
	int* all1 = new int[SIZE];//随机数组的三个排序副本
	int* all2 = new int[SIZE];
	int* all3 = new int[SIZE+1];

	srand((unsigned)time(NULL)); //用时间做种，每次产生随机数不一样

	for (int i = 0; i < SIZE; i++)
	{
		all[i] = rand() % SIZE + 1;  //产生随机数组
		all1[i] = all[i];
		all2[i] = all[i];
		all3[i+1] = all[i];
	}
	//printf("随机生成的数组为:\n");
	//for (int i = 0; i < SIZE; i++)
	//{
	//	printf("%d\t",all[i]);
	//	if ( (i+1) % 10 == 0)
	//		printf("\n");
	//}

	dStartTime1 = clock(); //Get The Start Time
	compare1(all1, 0, SIZE - 1);//比较排序函数，传入数组，数组头和尾index
	dEndTime1 = clock();

	dStartTime2 = clock();
	compare2(all2);
	dEndTime2 = clock();


	dStartTime3 = clock();
	compare3(all3);
	dEndTime3 = clock();


	//printf( "\n排序后输出：\n");
	//for (int i = 1; i <= SIZE; i++)
	//{
	//printf( "\t%d" , all3[i]);
	//if (i % 10 == 0)
	//	printf("\n");
	//}
	usetime1 = (dEndTime1 - dStartTime1) / CLOCKS_PER_SEC;
	usetime2 = (dEndTime2 - dStartTime2) / CLOCKS_PER_SEC;
	usetime3 = (dEndTime3 - dStartTime3) / CLOCKS_PER_SEC;
	printf("\n快速排序法所用时间: %.3f\n",usetime1);
	printf("\n冒泡排序法所用时间: %.3f\n", usetime2);
	printf("\n堆排序法所用时间: %.3f\n", usetime3);

	//delete[] all;
	//delete[] all1;
	//delete[] all2;
	//delete[] all3;
	return 0;
}


//快速排序算法
void compare1(int* all, int pos1, int pos2)
{
	int size = pos2 - pos1 + 1;
	int standard = all[pos1];
	int size1 = 0;
	int size2 = 0;
	int* half1 = new int[size - 1];//存放子序列
	int* half2 = new int[size - 1];
	for (int index = 1; index < size; index++)
	{
		if (all[pos1 + index] <= standard)
		{
			half1[size1] = all[pos1 + index];
			size1++;
		}
		else
		{
			half2[size2] = all[pos1 + index];
			size2++;
		}
	}
	if (size1 > 0)
	{
		for (int i = 0; i < size1; i++)
			all[pos1 + i] = half1[i];
		all[pos1 + size1] = standard;
		compare1(all, pos1, pos1 + size1 - 1);//对子序列递归调用
	}
	if (size2 > 0)
	{
		for (int j = 0; j < size2; j++)
			all[pos2 - j] = half2[j];
		compare1(all, pos2 - size2 + 1, pos2);//对子序列递归调用
	}
	delete[] half1;//注意释放内存，防止泄露
	delete[] half2;


}

//冒泡排序算法
void compare2(int* all)
{
	int i, j, temp;
	for (j = 0; j < SIZE; j++)
	{
		for (i = 0; i < SIZE - j; i++)
		{
			if (all[i] > all[i + 1])
			{
				temp = all[i];
				all[i] = all[i + 1];
				all[i + 1] = temp;
			}
		}
	}
}



//堆排序算法
void compare3(int* all)
{
	for (int i = SIZE / 2; i >= 1; i--) //构建一个大顶堆
		heapderactive(all, i, SIZE);
	for (int i = SIZE; i >= 1; i--)
	{
		swap(all[1], all[i]);
		heapderactive(all, 1, i - 1);
	}
}

void heapderactive(int* all, int i,int size)
{
	int lchild = 2 * i;       //i的左孩子节点序号 
	int rchild = 2 * i + 1;     //i的右孩子节点序号 
	int max = i;            //临时变量 
	if (i <= size / 2)          //如果i是叶节点就不用进行调整 
	{
		if (lchild <= size && all[lchild]>all[max])
		{
			max = lchild;
		}
		if (rchild <= size && all[rchild]>all[max])
		{
			max = rchild;
		}
		if (max != i)
		{
			swap(all[i], all[max]);
			heapderactive(all, max, size);    //避免调整之后以max为父节点的子树不是堆 
		}
	}
}

当排序元素个数达到100000，所用时间如下：