C++堆排序的实现(超详细)

本文提供了C++堆排序的完整代码实现,包括构建大根堆和小根堆的方法,通过上浮和下沉操作来实现排序过程。同时分析了堆排序的时间复杂度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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++归并排序(注释超详细)

评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值