堆与堆排序

二叉堆的定义

二叉堆是完全二叉树或者是近似完全二叉树。

二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。如下图所示

一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。

堆的建立

这里以大顶堆为例

#define  L  (2*x+1)
#define  R  (2*x+2)
void AdjustMaxHeap(int a[], int i, int n)    //调整大顶堆
{
	int MaxVal = a[i];
	int MaxNum = i;
	while(MaxNum < n)
	{
		int x = i;
		if(L<n && MaxVal < a[L])
		{
			MaxNum = L;
			MaxVal = a[L];
		}
		if(R<n && MaxVal < a[R])
		{
			MaxNum = R;
			MaxVal = a[R];
		}
		if(MaxNum == i)
			break;
		if(MaxNum < n)
			Swap(a[MaxNum], a[i]);
		i = MaxNum;
		MaxVal = a[i];
		MaxNum = i;
	}
}

int main()
{
	for(int i=n/2-1; i>=0; i--)   //堆化数组
		AdjustMaxHeap(a, i, n); 
	return 0;
}

堆的插入与删除

每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，现在的任务是将这个新数据插入到这个有序数据中。

堆中每次都只能删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最大的，如果父结点比这个最大的子结点还大说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。

void MaxHeapFix(int a[], int &n, int k)    //堆的插入
{
	a[n] = k;
	int i = (n-1)/2;
	int j = n;
	while(a[j] > a[i] && j!=0)
	{
		Swap(a[j], a[i]);
		j = i;
		i = (j-1)/2;
	}
	n++;
}

void MaxHeapDelete(int a[], int &n)           //堆的删除
{
	a[0] = a[n-1];
	n--;
	AdjustMaxHeap(a, 0, n);
}

堆排序

首先可以看到堆建好之后堆中第0个数据是堆中最大的数据。取出这个数据再执行下堆的删除操作。这样堆中第0个数据又是堆中最大的数据，重复上述步骤直至堆中只有一个数据时就直接取出这个数据。

堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最大的数据并入到后面的有序区间，故操作完成后整个数组就有序了。下面附上完整的代码：

//堆排序具体实现
#include <iostream>
#include <string.h>
using namespace std;
#define  N  1000
#define  L  (2*x+1)
#define  R  (2*x+2)
#define  MAX  0x3fffff

void Swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

void AdjustMaxHeap(int a[], int i, int n)    //调整大顶堆
{
	int MaxVal = a[i];
	int MaxNum = i;
	while(MaxNum < n)
	{
		int x = i;
		if(L<n && MaxVal < a[L])
		{
			MaxNum = L;
			MaxVal = a[L];
		}
		if(R<n && MaxVal < a[R])
		{
			MaxNum = R;
			MaxVal = a[R];
		}
		if(MaxNum == i)
			break;
		if(MaxNum < n)
			Swap(a[MaxNum], a[i]);
		i = MaxNum;
		MaxVal = a[i];
		MaxNum = i;
	}
}

void MaxHeapFix(int a[], int &n, int k)    //堆的插入
{
	a[n] = k;
	int i = (n-1)/2;
	int j = n;
	while(a[j] > a[i] && j!=0)
	{
		Swap(a[j], a[i]);
		j = i;
		i = (j-1)/2;
	}
	n++;
}

void MaxHeapDelete(int a[], int &n)           //堆的删除
{
	a[0] = a[n-1];
	n--;
	AdjustMaxHeap(a, 0, n);
}

int main()
{
	int a[N],n,k;
	while(cin>>n)
	{
		memset(a,0,sizeof(a));
		for(int i=0; i<n; i++)
			cin>>a[i];

		for(int i=n/2-1; i>=0; i--)   //堆化数组
			AdjustMaxHeap(a, i, n);  
		for(int i=0;i<n;i++)
			cout<<a[i];
		cout<<endl;

		cin>>k;
		MaxHeapFix(a, n, k);            //堆的插入
		for(int i=0;i<n;i++)
			cout<<a[i];
		cout<<endl;

		MaxHeapDelete(a, n);  //堆的删除
		for(int i=0;i<n;i++)
			cout<<a[i];
		cout<<endl;

		for(int i=n-1; i>=0; i--)     //堆排序
		{
			Swap(a[0], a[i]);
			AdjustMaxHeap(a, 0, i);
		}

		for(int i=0; i<n; i++)
			cout<<a[i]<<" ";
		cout<<endl;
	}
	return 0;
}

使用最大堆排序后是递增数组，要得到递减数组，可以使用最小堆，时间复杂度O(N * logN)。