堆排序（C++）

• 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。
• 堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

算法思想

• 首先将一个数组构造成一个最大堆/最小堆
• 然后将堆顶元素与最后一个元素交换位置，此时末尾元素就是最大值（或最小值）
• 然后将剩余的n-1个元素重新构造成最大堆（或最小堆）

所以，堆排序算法大概就分为两个步骤：

• 构造堆（调整数组，使其满足最大堆或最小堆）
• 排序

代码实现

先自己写了一遍：

#include<iostream>
using namespace std;

//从最后一个非叶子节点开始，求出每个小堆的最大值放在小堆的堆顶，直到根节点。
//这样，根节点的值则为整个堆里面的最大值，但这并不意味着它是一个大根堆。

void GetMaxValue(int tree[],int heapLen) 
{
	for(int i=(heapLen-1)/2;i>=0;i--)
	{
		int max=i;
		int left=2*i+1;
		int right=2*i+2;

		if(left<heapLen&&tree[left]>tree[max])
		{
			max=left;
		}

		if(right<heapLen&&tree[right]>tree[max])
		{
			max=right;
		}

		if(max!=i)
		{
			swap(tree[max],tree[i]);
		}
	}
}
void HeapSort(int arr[],int len)
{
	int heapLen=len;

	for(int i=0;i<len;i++)
	{
		GetMaxValue(arr,heapLen);//使堆顶元素是最大值
		swap(arr[0],arr[heapLen-1]);
		heapLen--;//在交换堆顶元素和数组最后一个元素的位置之后，下次堆的长度-1
	}
}

int main() 
{
	int arr[10]={1,3,7,85,3,6,8,2,9,12};
	int len=10;

	cout<<"排序前："<<endl;
	for(int i=0;i<10;++i)
	{
		cout<<arr[i]<<" ";
	}

	HeapSort(arr,len);//堆排序

	cout<<endl<<"排序后："<<endl;
	for(int j=0;j<10;j++)
	{
		cout<<arr[j]<<" ";
	}
	system("pause");
	return 0;
}

结果也是对的，但仔细一想，这和堆有什么关系，都根本不叫堆了，不满足根结点的值总是大于（小于）其子树的值啊。
在从最后一个非叶子结点往前遍历的时候，之后的值会受到影响，不满足堆的性质。

正确代码

这是百度来的代码：

#include <iostream>
#include <algorithm>
using namespace std;

void max_heapify(int arr[], int start, int end) 
{
	//建立父节点指标和子节点指标
	int dad = start;
	int son = dad * 2 + 1;
	while (son <= end)  //若子节点指标在范围内才做比较
	{    
		if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点大小，选择最大的
			son++;
		if (arr[dad] > arr[son]) //如果父节点大於子节点代表调整完毕，直接跳出函数
			return;
		else  //否则交换父子内容再继续子节点和孙节点比较
		{
			swap(arr[dad], arr[son]);
			dad = son;
			son = dad * 2 + 1;
		}
	}
}

void heap_sort(int arr[], int len) 
{
	//初始化，i从最後一个父节点开始调整，先构造一个大根堆
	for (int i = len / 2 - 1; i >= 0; i--)
		max_heapify(arr, i, len - 1);

	for (int i = len - 1; i > 0; i--) 
	{
		swap(arr[0], arr[i]);//先将第一个元素和已经排好的元素前一位做交换
		max_heapify(arr, 0, i - 1);//在大根堆的基础上，从堆顶开始，构造堆
	}
}

void main() 
{
	int arr[] = { 3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6 };
	int len = (int) sizeof(arr) / sizeof(*arr);
	cout<<"排序前："<<endl;
	for(int i=0;i<len;++i)
	{
		cout<<arr[i]<<" ";
	}

	heap_sort(arr, len);//堆排序

	cout<<endl<<"排序后："<<endl;
	for (int i = 0; i < len; i++)
		cout << arr[i] << ' ';
	cout << endl;
	system("pause");
}

在初始化为大根堆的基础上，控制start，从结点0开始，start后面的结点都会被构建为大根堆。

复杂度分析

时间复杂度

• 建堆：O(n)
• 排序：O(nlgn)

所以总的时间复杂度是O(nlgn)

空间复杂度

• 相当于原地排序算法，空间复杂度O(n)

稳定性分析

• 堆排序是不稳定的算法，在堆顶元素和最后一个元素交换时候，会改变相同元素的原始相对位置。