算法设计之-世界上最好理解的堆排序

堆排序

    堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。

堆

    堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

堆排序的基本思想：
    将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n-1个元素的次小值。如此反复执行，便能得到一个有序序列了.

接下来搞个例子：
如下图

1.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

2.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

接下来将剩下的部分最大顶化，得到如下

然后将5和8交换得到如下

如法炮制得到如下：

代码实现：

//交换数组a，i位置和j位置的元素
void swap(int a[], int i, int j)
{
	int nTmp = a[i];
	a[i] = a[j];
	a[j] = nTmp;
}

void Heapfy(int a[], int nSize, int i)
{

	if (i >=nSize)
	{
		return;
	}

	int nMax = i;
	int c1 = 2 * i + 1;
	int c2 = 2 * i + 2;

	if (a[c1] > a[nMax] && c1<nSize)
	{
		nMax = c1;

	}

	if (a[c2] > a[nMax]&&c2<nSize)
	{
		nMax = c2;

	}

	if (nMax != i)
	{
		swap(a, nMax, i);
		Heapfy(a, nSize, nMax);
	}

}
//将非叶子节点分别大顶堆
void buildHeap(int a[], int nsize)
{
	int nParent = nsize / 2 - 1;
	for (int i = nParent;i>=0;i--)
	{
		Heapfy(a, nsize, i);
	}
}

void Heap_sort(int a[], int nsize)
{
	buildHeap(a, nsize);
	for (int i = nsize-1;i>0;i--)
	{
	//每次循环都将最大的根节点放在数组的最末尾，然后再调整头节点
		swap(a, i, 0);
		Heapfy(a, i, 0);
	}
}

void main()
{
	int a[] = { 4, 6, 8, 5, 9,1,2,3,7,100,0 };
	Heap_sort(a, sizeof(a) / a[0]);
	for (auto node:a)
	{
		cout << node << " ";
	}
	cout << endl;

	int b[] = { 8,9,1,5,22,67,33,47,9,1,18,22,55,-1,99,22 };

	int nblen = sizeof(b) / sizeof(b[0]);

	Heap_sort(b, nblen);

	for (auto nodex : b)
	{
		cout << nodex << " ";
	}

	cout << endl;
	
	system("pause");
}

结果：