排序算法之六 堆排序(C++版本)

一. 实现原理

堆排序的相关知识，参考漫画：什么是堆排序？ 堆排序算法（图解详细流程）

还有一个基本概念：查找数组中某个数的父结点和左右孩子结点，比如已知索引为i的数，那么

1. 父结点索引：(i-1)/2（这里计算机中的除以2，省略掉小数）
2. 左孩子索引：2*i+1
3. 右孩子索引：2*i+2

二. 具体实现

void InsertHeap(int* pData, int size)
{
	// 自下向上的过程
	if (nullptr == pData || size < 1) return;
	
	for (int idx = size - 1; idx >= 1; --idx) // 注意idx结束条件 意味着不处理根节点(无父节点)
	{
		int curIdx = idx; // 待处理的节点
		int parentIdx = (curIdx - 1) / 2; // 父节点
		if (pData[curIdx] > pData[parentIdx]) std::swap(pData[curData]), pData[parentIdx]); // 当前节点比父节点大 交换
	}
}

void Heapify(int* pData, int end)
{
	// 至上而下的过程
	if (nullptr == pData || end <= 0) return;
	
	int curIdx = 0; // 从根节点开始
	while (true)
	{
		int leftIdx = 2 * curIdx + 1; // 左子节点
		int rightIdx = 2 * curIdx + 2; // 右子节点
		int biggerIdx = 0; // 左右子节点的较大节点
		
		if (leftIdx > end) break; // 无子节点
		else if (rightIdx  > end) biggerIdx = leftIdx; // 无右子节点
		else  biggerIdx = pData[leftIdx] >= pData[rightIdx] ? leftIdx : rightIdx; // 

		if (pData[curIdx] >= pData[biggerIdx]) break; // 当前节点大于等于其左右子节点，满足条件，结束循环
		
		std::swap(pData[curIdx], pData[biggerIdx]);
		curIdx = biggerIdx; // 下到子节点中的较大节点，继续循环
	}
}

void HeapSort(int* pData, int size)
{
	if (nullptr == pData || size <= 0) return;

	InsertHeap(pData, size); // 将初始数据整理成最大堆
	for (int idx = size - 1; idx > 0; --idx) // 从后往前处理，idx = 0时只有一个元素，无需再处理
	{
		std::swap(pData[0], pData[idx]); // 根节点为最大值，将其交换到数组尾部
		Heapify(pData, idx - 1); // 再次进行堆化 
	}
}

三. 输出验证

加上相关的输出信息后再进行调用。

辅助函数：

void Print(int* pData, int size)
{
	for (int idx = 0; idx < size; ++idx) std::cout << pData[idx] << " ";
	std::cout << std::endl;
}

初始数据为：

int datas[6] = { 1, 2, 3, 2, 1, 6 };

输出版本：

void InsertHeap_Output(int* pData, int size)
{
	// 自下向上的过程
	if (nullptr == pData || size <= 0) return;
	
	for (int idx = 0; idx < size; ++idx)
	{
		int curIdx = idx; // 待处理的节点
		while (true)
		{
			int parentIdx = (curIdx - 1) / 2; // 父节点
			if (parentIdx < 0) break; // 如果是处理第一个节点，需要这个
			if (pData[curIdx] <= pData[parentIdx]) break; // 当前节点小于等于父节点，已经满足条件，结束判断
			std::swap(pData[curIdx], pData[parentIdx]); 
			curIdx = parentIdx; // 当前节点指向其父节点，继续比较
		}
	}

	std::cout << std::endl << "INSERT HEAP END" << std::endl;
	Print(pData, size);
}

void Heapify_Output(int* pData, int end)
{
	// 至上而下的过程
	if (nullptr == pData || end <= 0) return;

	int curIdx = 0; // 从根节点开始
	while (true)
	{
		int leftIdx = 2 * curIdx + 1; // 左子节点
		int rightIdx = 2 * curIdx + 2; // 右子节点
		if (leftIdx > end) break; // 当前节点已经没有子节点了

		int biggerIdx = 0; // 左右子节点的较大节点
		if (rightIdx > end) biggerIdx = leftIdx; // 无右子节点
		else biggerIdx = pData[leftIdx] >= pData[rightIdx] ? leftIdx : rightIdx;

		if (pData[biggerIdx] <= pData[curIdx]) break; // 当前节点大于等于其左右子节点，满足条件，结束循环
		std::swap(pData[biggerIdx], pData[curIdx]);
		curIdx = biggerIdx; // 下到较大节点，继续循环
	}

}

void HeapSort_Output(int* pData, int size)
{
	if (nullptr == pData || size <= 0) return;

	InsertHeap_Output(pData, size);

	for (int idx = size - 1; idx > 0; --idx)
	{
		std::swap(pData[0], pData[idx]); // 根节点为最大值，将其交换到数组尾部

		std::cout << std::endl << "SWAP 0 AND " << idx << std::endl;
		Print(pData, size);

		Heapify_Output(pData, idx - 1); // 再次就行堆化
		std::cout << std::endl << "HEAPIFY" << std::endl;
		Print(pData, size);
	}
}

调用输出

INIT DATA
1 2 3 2 1 6

INSERT HEAP END
6 2 3 1 1 2

SWAP 0 AND 5
2 2 3 1 1 6

HEAPIFY
3 2 2 1 1 6

SWAP 0 AND 4
1 2 2 1 3 6

HEAPIFY
2 1 2 1 3 6

SWAP 0 AND 3
1 1 2 2 3 6

HEAPIFY
2 1 1 2 3 6

SWAP 0 AND 2
1 1 2 2 3 6

HEAPIFY
1 1 2 2 3 6

SWAP 0 AND 1
1 1 2 2 3 6

HEAPIFY
1 1 2 2 3 6

FINAL DATA
1 1 2 2 3 6