数据结构---------堆排序

    说到堆排序，它的思想来源于优先队列，我们首先来说一下什么是优先队列。

一、优先队列

1.优先队列的定义：优先队列是允许以下两种操作的数据结构：Insert（插入）相当于入队、DeleteMin（删除最小元）。

2.使用数据结构：相比于单链表和二叉排序树的缺点，我们使用二叉堆这种结构，它有两个重要的性质就是：

1.     结构性——完全二叉树
2.     堆序行——小顶堆或大顶堆

3.实现：因为完全二叉树有规律，我们使用数组实现，对于数组中任一位置i上的元素，其左儿子为2*i，右儿子为 2*i+1，父亲为  i/2，（下标从1开始 ）。

4.思想：

1. 插入：将一个元素X插入到堆中后，我们在下一个位置创建一个空穴，如果X不破坏堆结构，那么Insert完成。否则，我们把该空穴的父亲节点移动到该空穴，直到X被放入到空穴为止。我们把这种操作称为上滤。
2. 删除最小元：删除最小元后产生一个空穴，堆中最后一个元素X必须移动到堆中的某个地方，如果X可以被放到空穴，那么DeleleMin完成，否则，将空穴较小的儿子移入空穴，直至X被移动到正确的位置。我们把这种操作称为下滤。

5.实现：

声明：

#include <stdio.h>
#include <stdlib.h>


#define ElementType int


/*
优先队列数组实现
*/
typedef struct HeapStrcut	//堆结构
{
	int Capcity;
	int Size;
	ElementType *Elements;
}*PriorityQueue;


PriorityQueue Initialize(int MaxElements);  //创建初始化优先队列
void Insert(ElementType X, PriorityQueue H);//插入
ElementType DeleteMin(PriorityQueue H);	    //删除最小节点
int IsEmpty(PriorityQueue H);		    //判断优先队列是否为空
int IsFull(PriorityQueue H);		    //判断优先队列是否已满

实现：

/*
创建初始化优先队列
小顶堆，最小元在根节点
*/
PriorityQueue Initialize(int MaxElements)
{
	PriorityQueue H;
	//申请优先队列结构空间
	H = (PriorityQueue)malloc(sizeof(struct HeapStrcut));
	if(NULL == H)
	{ 
		printf("Out of space.\n");
		exit(-1);
	}
	//申请存储数据数组Elements空间
	H->Elements = (ElementType *)malloc(sizeof(ElementType)*MaxElements);
	if (H->Elements == NULL)
	{
		printf("Out of space.\n");
		exit(-1);
	}
	//初始化优先队列
	H->Capcity = MaxElements;
	H->Size = 0;
}

/*
插入，交换而实施的赋值语句为d+1
*/
void Insert(ElementType X, PriorityQueue H)
{
	int i;

	if(IsFull(H))
	{ 
		printf("The PriorityQueue is full.\n");
		exit(-1);
	}
	
	for (i = ++H->Size; H->Elements[i / 2] > X; i /= 2)
		H->Elements[i] = H->Elements[i / 2];
	H->Elements[i] = X;
}
//我的插入写法，交换而实施的赋值语句为3d
void Insert2(ElementType X, PriorityQueue H)
{
	int i, tmp;

	if (IsFull(H))
	{
		printf("The PriorityQueue is full.\n");
		exit(-1);
	}

	H->Elements[++H->Size] = X;
	tmp = H->Elements[H->Size];
	for (i = H->Size; i / 2 > 0; i /= 2)
		if (H->Elements[i / 2] > H->Elements[i])
			H->Elements[i] = H->Elements[i / 2];
		else
			break;
	H->Elements[i] = tmp;
}

/*
删除最小节点
*/
ElementType DeleteMin(PriorityQueue H)
{
	int i, child;
	ElementType MinElement, LastElement;

	if (IsEmpty(H))
	{
		printf("The PriorityQueue is empty.\n");
		exit(-1);
	}
	MinElement = H->Elements[1];
	LastElement = H->Elements[H->Size--];

	for (i = 1; i * 2 <= H->Size; i = child)
	{
		//查找较小的子节点
		child = i * 2;
		if (child != H->Size && H->Elements[child + 1] < H->Elements[child])
			child++;

		//下滤操作
		if (LastElement > H->Elements[child])
			H->Elements[i] = H->Elements[child];
		else
			break;
	}
	H->Elements[i] = LastElement;
	return MinElement;
}

/*
判断优先队列是否为空
*/
int IsEmpty(PriorityQueue H)
{
	return H->Size == 0;
}

/*
判断优先队列是否已满
*/
int IsFull(PriorityQueue H)
{
	return H->Size == H->Capcity;
}

/*
显示优先队列元素
*/
void show(PriorityQueue H)
{
	int i;
	for (i = 1; i <= H->Size; i++)
		printf("%d\t", H->Elements[i]);
	printf("\n");
}







int main()
{
	int max_elements, flag=1, choose, value;

	//构建优先队列
	printf("开始构建优先队列\n");
	printf("请输入优先队列大小：\n");
	scanf("%d", &max_elements);
	PriorityQueue H = Initialize(max_elements);
	
	//优先队列操作
	while (flag)
	{
		printf("请输入操作，1.插入 2.删除最小元 3.显示优先队列元素.\n");
		scanf("%d", &choose);
		switch (choose)
		{
		case 1:
			printf("请输入插入元素\n");
			scanf("%d", &value);
			Insert(value, H);
			break;

		case 2:
			DeleteMin(H);
			show(H);
			break;

		case 3:
			show(H);
			break;

		default:
			flag = 0;
			break;
		}
	}




    return 0;
}

二、堆排序

1.思路：将要排序的数据构建成小顶堆，交换根与最后节点，下滤重新构建堆。

2.实现：

       数组实现，下标从0开始：

/*
堆排序
思路：堆排序分为构建堆、删除最值、调整堆即上滤下滤操作。
方法：使用数组代替ADT（抽象数据类型）的方式实现初始堆数组下标从零开始。
总结：时间复杂度为N*logN。
*/

//上滤操作
void PercDown(ElementType A[], int i, int N)	//i为父节点下标
{
	int replChild;		//下滤操作时用来与根节点交换的孩子节点下标
	ElementType tmp;	//一般利用交换进行的排序都要有一个tmp变量

	//每次开始都要取出最顶点下标，所以可以写在for语句头中作为初始条件
	//遍历的条件就是父节点还有孩子
	//执行完此次下滤操作后需要找到下次下滤操作的父节点，所以我们也可以写到for语句头
	for (tmp = A[i]; 2*i+1 < N; i = replChild)	//i = replChild是在语句体执行之后执行的
	{
		if (2 * i + 1 != N - 1 && A[2 * i + 1] < A[2 * i + 1 + 1])//若右孩子存在且右孩子大则将右孩子下滤
			replChild = 2 * i + 1 + 1;
		if (2 * i + 1 != N - 1 && A[2 * i + 1] > A[2 * i + 1 + 1])//若右孩子存在且右孩子小则将左孩子下滤
			replChild = 2 * i + 1;
		if(2 * i + 1 == N - 1)		//若右孩子不存在则将左孩子下滤
				replChild = 2 * i + 1;

		//书上方法
		//replChild = 2*i+1;
		//if (replChild != N - 1 && A[replChild + 1] > A[replChild])
		//	replChild++;

		//满足孩子比父亲数据大,将孩子数据赋值父亲数据,
		//否则，不满足堆结构，不需要下滤跳出循环
		if (tmp < A[replChild])
			A[i] = A[replChild];
		else
			break;
	}
	A[i] = tmp;
}

//堆排序
void HeapSort(ElementType A[], int N)
{
	int i, temp;;

	for (i = N / 2; i >= 0; i--)
		PercDown(A, i, N);
	for (i = N - 1; i > 0; i--)
	{	//交换根与最后的节点数据
		temp = A[0];
		A[0] = A[i];
		A[i] = temp;

		PercDown(A, 0, i);
	}
}

3.分析：堆排序的时间复杂度为O（longN），构建N个数据的二叉堆需要O（N）时间，DeleteMin需要O（NlogN）时间。

              堆排序是一个稳定的排序，无论起始的数据序列是如何的。