数据结构与算法-堆排序

堆的特点： 完全二叉树+父节点值大于子节点

完全二叉树的重要性质： 将完全二叉树的节点按照层序遍历的顺序依次输入到一个数组中，那么任意一个子节点和父节点在数组中的索引有如下数量关系

parent=(i-1)/2
c1=2i+1//左孩子
c2=2i+2//右孩子

核心思想：输入一个乱序数组，将他按照层序遍历的顺序逐个填成一个完全二叉树，然后把这棵完全二叉树变成一个大根堆，然后得到当前的最大值，交换到数组的末尾，然后再重复操作，又搞成一个大根堆。再次交换，重复上述过程直到所有元素都排好序。
整体步骤分三步：
1.首先实现单个节点的heapfiy操作，要记忆一下子节点和父节点关系的公式
2.实现输入一个乱序数组，输出一个大根堆，heapify_build
3.大根堆的第一个元素为最大，每次操作得到一个最大交换到数组的末尾，每次确定一个最大的元素。heapify_sort

heapfiy操作

//对于某一个节点  使得根节点、左孩子、右孩子构成一个大顶堆  根大于左右
//同时对该节点底下的节点继续做heapfiy  直到叶子节点
//只有被交换的那个分支被破坏了，所以只需要递归那个分支
/数组的第i个节点执行heapify操作 取闭区间
void heapify(vector<int>& tree, int n, int i)
{
	//左右孩子索引
	int left = 2*i + 1;
	int right = 2*i + 2;

	//寻找根左右的最大值 相等不用换 
	//如果left right 超出数组范围也就是空了就排除
	int max = i;
	if (left<=n&&tree[left] > tree[max])  max = left;
	if (right<=n&&tree[right] > tree[max])  max = right;
	
	//如果根不是最大的，需要交换
	if (max != i)
	{
		swap(tree[i], tree[max]);
		//递归到交换过的节点继续进行heapify
		heapify(tree, n, max);
	}
}

heapify_build操作

根据输入的数组建立一个大根堆 从倒数第二层的第一个节点开始一直往前走

//根据输入的数组建立一个大根堆 从倒数第二层的第一个节点开始一直往前走  闭区间
void heapify_build(vector<int>& tree, int n)
{
	//最后一个节点的父节点就是倒数第二层的第一个节点
	int start = (n - 1) / 2;

	for (int i = start; i >= 0; i--)
	{
		heapify(tree, n,i);
	}

}

heapify_sort操作

建立大根堆后，每次交换最后一个节点和根节点（最大值） 也就是把当前最大值放到数组末尾

//对交换后的二叉树再进行heapify 使他再次成为一个大顶堆

//闭区间
void heapify_sort(vector<int>& tree, int n)
{
	//先根据输入的数组建立一个大根堆
	heapify_build(tree, n);
	for (int i = 0; i < tree.size(); i++)
	{
		cout << tree[i] << endl;
	}
	
	//把根节点和最后一个节点交换 传入数组长度-1
	//每次循环在数组末尾确定一个最大值
	for (int i = 0; i <= n; i++)
	{		
		swap(tree[0], tree[n-i]);	
		//交换后破坏了大根堆的规则
		heapify(tree, n - i-1, 0);
	}

}

堆排序完整代码

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

//数组的第i个节点执行heapify操作 取闭区间
void heapify(vector<int>& tree, int n, int i)
{
	//左右孩子索引
	int left = 2*i + 1;
	int right = 2*i + 2;

	//寻找根左右的最大值 相等不用换 
	//如果left right 超出数组范围也就是空了就排除
	int max = i;
	if (left<=n&&tree[left] > tree[max])  max = left;
	if (right<=n&&tree[right] > tree[max])  max = right;
	
	//如果根不是最大的，需要交换
	if (max != i)
	{
		swap(tree[i], tree[max]);
		//递归到交换过的节点继续进行heapify
		heapify(tree, n, max);
	}
}
//根据输入的数组建立一个大根堆 从倒数第二层的第一个节点开始一直往前走  闭区间
void heapify_build(vector<int>& tree, int n)
{
	//最后一个节点的父节点就是倒数第二层的第一个节点
	int start = (n - 1) / 2;

	for (int i = start; i >= 0; i--)
	{
		heapify(tree, n,i);
	}

}
//闭区间
void heapify_sort(vector<int>& tree, int n)
{
	//先根据输入的数组建立一个大根堆
	heapify_build(tree, n);
	//把根节点和最后一个节点交换 传入数组长度-1
	//每次循环在数组末尾确定一个最大值
	for (int i = 0; i <= n; i++)
	{		
		swap(tree[0], tree[n-i]);	
		//交换后破坏了大根堆的规则
		heapify(tree, n - i-1, 0);
	}

}

int main()
{
	vector<int> tree= { 3,7,8,0,1,9,3 };
	
	heapify_sort(tree, tree.size()-1);

	for (int i = 0; i < tree.size(); i++)
	{
		cout << tree[i] << endl;
	}

}

时间复杂度分析
1.把一个n个节点的完全二叉树转换为大根堆需要交换 logN 次
2.n-1个节点全部执行操作1（每一次转换操作得到一个确定的最大元素） (n-1)logN
所以总的时间复杂度是NlogN

堆排序实际表现较差，实际效果接近冒泡。。。。

空间复杂度 O(1)

稳定性
堆排序不稳定

堆排序的拓展
top-N 问题 在n个乱序的数据中最快的找到最大的n个数