C++堆排序的实现（超详细）

C++堆排序的实现完整代码

分享一篇讲解堆排序基本概念的文章，很生动形象：

https://mp.weixin.qq.com/s?__biz=MzIwNTc4NTEwOQ==&mid=2247484709&idx=2&sn=7bd9b16069d5a37f9ef521c33f947564

1、HeapSort.h

/* 初始版本，升序排序 */
/* 时间复杂度O(nlbn)，空间复杂度O(1) */
/* 不稳定，如排序 5 7 13 5`
	建成大根堆 13 7 5 5`
	第一次排序并调整：7 5` 5 13
	第二次排序并调整：5 5` 7 13 （排序完成）
*/

#ifndef HEAPSORT_H
#define HEAPSORT_H

#include <iostream>
#include <stdlib.h>
// using namespace std;

/*
* 用以比较，
* a > b ，建立大根堆，升序排序
* a < b ，建立小根堆，降序排序
*/
bool cmp(const int &a, const int &b){
	return a > b;
}

/***************
* 传入的数组起始节点从0开始，对于下标为k的节点来说：
* 左孩子位置：2k + 1
* 右孩子位置：2k + 2
* 父亲节点位置：(k - 1) / 2
****************/

/*
* 上浮操作，比较节点与其父节点，满足条件则交换子和父的值
*/
void swim(int* const arr, const int &k){
	int parent = (k - 1) / 2;	// 求出待插入元素父节点的位置
	if(parent < 0 || arr == nullptr) return;	// 父节点不存在或者数组本身为空


	if(cmp(arr[k], arr[parent])){	// 该节点大于父节点
		std::swap(arr[k], arr[parent]);	// 交换节点值
		swim(arr, parent);	// 继续上浮
	}
}

/*
* 下沉操作，比较节点与其子节点，满足条件则交换子和父的值
* 如果是大根堆，节点应该与值大的子节点交换
* 如果是小根堆，节点应该与值小的子节点交换
*/
void sink(int* arr, const int &heapSize, const int &k){
	if(arr == nullptr) return;


	int maxOne = k;	// 保存最大节点的下标，初始为父节点


	int leftChild = 2 * k + 1;	// 求出左孩子的位置
	if(leftChild < heapSize) 	// 左孩子未越界
		maxOne = cmp(arr[leftChild], arr[k]) ? leftChild : k;	// 与左孩子节点比较，选取较大节点的下标


	int rightChild = 2 * k + 2;	// 求出右孩子的位置
	if(rightChild < heapSize)	// 右孩子未越界
		maxOne = cmp(arr[maxOne], arr[rightChild]) ? maxOne : rightChild;


	if(maxOne != k){
		std::swap(arr[k], arr[maxOne]);	// 值最大的节点不是该父节点，
		sink(arr, heapSize, maxOne);	// 该父节点继续下沉
	}
}

/*
* 删除堆根节点时，先与最后一个节点进行交换，交换后，堆大小减1，并对根节点进行下沉调整
*/
void deleteTop(int* arr, int &heapSize){
	std::swap(arr[0], arr[heapSize - 1]);
	--heapSize;
	sink(arr, heapSize, 0);
}

/*
* 每一个叶子节点可以看成一个大小唯一的堆
* 从最后一个非叶子节点(即最后一个节点的父节点)开始，对每一个节点进行下沉操作
* 这样以当前节点为根节点的树就变成堆了
*/
void buildHeap(int* arr, const int &heapSize){
	int i = (heapSize - 1) / 2;
	for( ; i >= 0; --i)
		sink(arr, heapSize, i);
}


void HeapSort(int* arr, int size){
	// 建大根堆，用以升序排序
	int heapSize = size;	// 为了删除的时候改变的不是原本size的值
	buildHeap(arr, size);
	// size 个元素的大根堆，排序(删除堆顶) size - 1 次， 数组就变成升序了
//	for(int i = 0; i < size; ++i)
//		std::cout << arr[i] << " ";
	for(int i = 0; i < size - 1; ++i){
		deleteTop(arr, heapSize);	// 删除堆顶会修改size的大小
	}
}

/*
* 时间复杂度分析：https://mp.weixin.qq.com/s?__biz=MzIwNTc4NTEwOQ==&mid=2247484709&idx=2&sn=7bd9b16069d5a37f9ef521c33f947564
* 建堆：O(n)
* 定义叶子节点高度为0，对于高为h的节点下沉代价为O(h)
* 堆中所有元素下沉代价之和就是建堆的代价（时间复杂度）
* n个元素的堆，高度为h的节点最多有[n/2^(h+1)]
* n个元素的堆高度为[lbn]
* 对于h = [0, lbn]，求和Σ[n/2^(h+1)]O(n) = O(nΣh/2^(h+1))，让n趋于无穷，则lbn趋于无穷
* 对于0到无穷的Σ[h*x^h] = x/(1-x)^2
* 所以，对于0到无穷的Σ[h/2^(h+1)] = (1/2)/(1-1/2)^2 = 2
* 所以对于h = [0, lbn]，求和Σ[n/2^(h+1)]O(n) = O(nΣh/2^(h+1))，结果为O(2n) = O(n)
* 删除：O(nlbn)
* n - 1次调用deleteTop
* deleteTop中包含swap和sink，swap代价为常数，sink代价为lbn
* 相当于进行了n - 1次sink
* 则共花费 (n-1)lbn，时间复杂度为O(nlbn)
*/

#endif // HEAPSORT_H

2、main.cpp

#include "HeapSort.h"

int main()
{
    int arr[] = {5, 13 ,7 ,5};
    HeapSort(arr, 4);

    for(int i = 0; i < 4; ++i)
        std::cout << arr[i] << " ";
    return 0;
}

排序不得不看之：C++快速排序的实现（注释超详细）

排序不得不看之：C++归并排序（注释超详细）