堆类模板-C++实现

最新推荐文章于 2024-05-13 09:00:00 发布
最新推荐文章于 2024-05-13 09:00:00 发布
阅读量381 收藏
点赞数 3
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55464171/article/details/117196820
版权

目录

什么是堆

堆是一种重要的数据类型，是一种特殊的完全二叉树。
堆的递归定义为：
1）堆可以是一棵空树。
2）如果堆不为空，则堆的根结点比所有子孙结点大（或小）。
3）堆的子树也是堆。
根据堆的定义，可以得出：从堆的根结点沿任意路径到叶节点，经过的结点具有有序性。
例：如下图所示的一棵二叉树
在这里插入图片描述
从树的根结点到叶节点的全体路径为：
10 7 5
10 7 1
10 2
全体路径都是从大到小的序列，并且该二叉树是完全二叉树，故该二叉树是堆。
像这样沿任意路径，结点递降的堆，叫做最大堆（或大根堆）；同理，沿任意路径，结点递增的堆，叫做最小堆（或小根堆）。

堆的基本操作：最大堆为例

堆是一棵完全二叉树，所以可以用数组实现堆。

template<class T, int MaxSize>	//T是堆中存放的数据类型，MaxSize是堆的最大容量
class MaxHeap {
private:
   T buffer[MaxSize];	//存放堆的数组
   int _size;	//堆的当前数据量
   static T out_of_range;	//试图访问空堆时，返回越界数据
public:
   MaxHeap();	//构造函数
   void insert(T const&insert_element);	//插入操作
   T pop_max();	//弹出最大数据：根结点对应的数据
   void clear();	//清空堆
   bool empty()const;	//判断堆是否为空
   bool full()const;	//判断堆是否为满
   int size()const;	//返回堆的当前数据线
   int max_size()const;	//返回堆的最大容量
};

最大堆的插入：向上调整

最大堆的插入分两步进行：
1）插入：和完全二叉树一样，直接把数据插入到堆的最后一个结点末尾。
2）有序性调整：前文提到，从堆的根结点沿任意路径到叶节点，经过的结点具有有序性。但是插入的新结点可能破坏堆的有序性，所以需要从下向上调整。
具体的调整方法为：从插入的结点开始，依次和父结点比较，如果父结点较小，就交换父结点与插入结点，直到插入结点不大于父结点为止。

template<class T, int MaxSize>
void MaxHeap<T, MaxSize>::insert(T const&insert_element) {
	if (full())return;	//如果堆满，则不进行插入
	buffer[_size] = insert_element;	//在堆的最后一个结点末尾插入数据
	if (!_size++)return;	//如果堆为空，则可以直接返回
	int pos = _size - 1, father;	//pos记录插入结点下标，father记录父结点下标
	while (pos) {	//当插入结点调整为根结点时结束循环
		father = (pos - 1) / 2;	//由完全二叉树的性质，父结点的下标由左式给出
		if (buffer[father] < buffer[pos]) {	//如果父结点较小，就交换父结点与插入结点
			auto temp = buffer[father];
			buffer[father] = buffer[pos];
			buffer[pos] = temp;
			pos = father;
		}
		else break;	//插入结点不大于父结点，有序性调整结束
	}
}

弹出最大数据：向下调整

由最大堆的定义，最大数据在根结点上，所以需要删除根结点，并返回根结点的数据。
最大堆的删除分三步进行：
1）交换：交换根结点与最后一个结点的位置，方便删除操作。
2）删除：由于根结点与最后一个结点换位，只需要删除最后一个结点。
2）有序性调整：最后一个结点被换到根结点上，很可能破坏堆的有序性，所以需要从上向下调整。
具体的调整方法为：从跟结点开始，依次和较大的子结点比较，如果父结点较小，就交换父结点与较大子结点，直到根结点不小于任意子结点为止。

template<class T, int MaxSize>
T MaxHeap<T, MaxSize>::pop_max() {
	if (empty())return out_of_range;	//如果堆为空，则直接返回
	auto output = *buffer;	//因为要删除根结点，先记录下根结点的数据
	*buffer = buffer[_size-- - 1];	//交换根结点与最后一个结点，并删除最后一个结点
	if (1 == _size)return output;	//如果堆只剩下一个结点，则直接返回原根结点数据
	int pos = 0, l_child, r_child;	//pos记录根结点下标，l_child和r_child分别记录左右子结点下标
	while (2 * pos + 1 < _size) {	//当根结点被调整到叶节点上时，结束有序性调整
		l_child = 2 * pos + 1;
		r_child = 2 * pos + 2;	//由完全二叉树的性质，子结点的下标由左式给出
		if (2 * pos + 2 == _size)
			if (buffer[l_child] > buffer[pos]) {
				auto temp = buffer[l_child];
				buffer[l_child] = buffer[pos];
				buffer[pos] = temp;
				pos = l_child;
			}
			else break;
		else if (buffer[l_child] > buffer[r_child])	//选择较大的子结点，与根结点比较
			if (buffer[l_child] > buffer[pos]) {	//如果根结点较小，则交换根结点与该子结点
				auto temp = buffer[l_child];
				buffer[l_child] = buffer[pos];
				buffer[pos] = temp;
				pos = l_child;
			}
			else break;	//根结点不小于任意子结点，有序性调整结束
		else if (buffer[r_child] > buffer[pos]) {
			auto temp = buffer[r_child];
			buffer[r_child] = buffer[pos];
			buffer[pos] = temp;
			pos = r_child;
		}
		else break;
	}
	return output;	//返回原根结点的数据
}

最小堆的操作与最大堆类似，本文不做赘述。

使用堆的注意事项

如果堆储存的是用户定义的数据类型，则需要重载关系运算符，或者指定一个键值作为比较数据大小的基准。
例：用最小堆实现哈夫曼编码。
构造哈夫曼树的依据是结点的权值，所以应该指定结点的权值为键值。

完整代码

//堆：数组实现
#ifndef OCHEAP_H
#define OCHEAP_H

#ifndef _OC_BEGIN
#define _OC_BEGIN namespace OC{
#endif

#ifndef _OC_END
#define _OC_END }
#endif

#ifndef OCHEAP_DEBUG
#define OCHEAP_DEBUG 0
#include<iostream>
using std::cout;
using std::endl;
#endif

_OC_BEGIN

//_MAXHEAP_BEGIN

template<class T, int MaxSize>
class MaxHeap {
private:
	T buffer[MaxSize];
	int _size;
	static T out_of_range;
public:
	MaxHeap();
	void insert(T const&insert_element);
	T pop_max();
	void clear();
	bool empty()const;
	bool full()const;
	int size()const;
	int max_size()const;
#if OCHEAP_DEBUG
	void LevleOrderTraversal()const {
		auto it = buffer;
		for (int count = 0; count != _size; count++)
			cout << *it++ << ' ';
	}
#endif
};

template<class T, int MaxSize>
T MaxHeap<T, MaxSize>::out_of_range;

template<class T, int MaxSize>
MaxHeap<T, MaxSize>::MaxHeap() :_size(0) {

}

template<class T, int MaxSize>
void MaxHeap<T, MaxSize>::insert(T const&insert_element) {
	if (full())return;
	buffer[_size] = insert_element;
	if (!_size++)return;
	int pos = _size - 1, father;
	while (pos) {
		father = (pos - 1) / 2;
		if (buffer[father] < buffer[pos]) {
			auto temp = buffer[father];
			buffer[father] = buffer[pos];
			buffer[pos] = temp;
			pos = father;
		}
		else break;
	}
}

template<class T, int MaxSize>
T MaxHeap<T, MaxSize>::pop_max() {
	if (empty())return out_of_range;
	auto output = *buffer;
	*buffer = buffer[_size-- - 1];
	if (1 == _size)return output;
	int pos = 0, l_child, r_child;
	while (2 * pos + 2 < _size) {
		l_child = 2 * pos + 1;
		r_child = 2 * pos + 2;
		if (buffer[l_child] > buffer[r_child])
			if (buffer[l_child] > buffer[pos]) {
				auto temp = buffer[l_child];
				buffer[l_child] = buffer[pos];
				buffer[pos] = temp;
				pos = l_child;
			}
			else break;
		else if (buffer[r_child] > buffer[pos]) {
			auto temp = buffer[r_child];
			buffer[r_child] = buffer[pos];
			buffer[pos] = temp;
			pos = r_child;
		}
		else break;
	}
	return output;
}

template<class T, int MaxSize>
void MaxHeap<T, MaxSize>::clear() {
	_size = 0;
}

template<class T, int MaxSize>
bool MaxHeap<T, MaxSize>::empty()const {
	return _size ? false : true;
}

template<class T, int MaxSize>
bool MaxHeap<T, MaxSize>::full()const {
	return _size == MaxSize ? true : false;
}

template<class T, int MaxSize>
int MaxHeap<T, MaxSize>::size()const {
	return _size;
}

template<class T, int MaxSize>
int MaxHeap<T, MaxSize>::max_size()const {
	return MaxSize;
}

//_MAXHEAP_END

//_MINHEAP_BEGIN

template<class T, int MaxSize>
class MinHeap {
private:
	T buffer[MaxSize];
	int _size;
	static T out_of_range;
public:
	MinHeap();
	void insert(T const&insert_element);
	T pop_min();
	void clear();
	bool empty()const;
	bool full()const;
	int size()const;
	int max_size()const;
#if OCHEAP_DEBUG
	void LevleOrderTraversal()const {
		auto it = buffer;
		for (int count = 0; count != _size; count++)
			cout << *it++ << ' ';
	}
#endif
};

template<class T, int MaxSize>
T MinHeap<T, MaxSize>::out_of_range;

template<class T, int MaxSize>
MinHeap<T, MaxSize>::MinHeap() :_size(0) {

}

template<class T, int MaxSize>
void MinHeap<T, MaxSize>::insert(T const&insert_element) {
	if (full())return;
	buffer[_size] = insert_element;
	if (!_size++)return;
	int pos = _size - 1, father;
	while (pos) {
		father = (pos - 1) / 2;
		if (buffer[father] > buffer[pos]) {
			auto temp = buffer[father];
			buffer[father] = buffer[pos];
			buffer[pos] = temp;
			pos = father;
		}
		else break;
	}
}

template<class T, int MaxSize>
T MinHeap<T, MaxSize>::pop_min() {
	if (empty())return out_of_range;
	auto output = *buffer;
	*buffer = buffer[_size-- - 1];
	if (1 == _size)return output;
	int pos = 0, l_child, r_child;
	while (2 * pos + 2 < _size) {
		l_child = 2 * pos + 1;
		r_child = 2 * pos + 2;
		if (buffer[l_child] < buffer[r_child])
			if (buffer[l_child] < buffer[pos]) {
				auto temp = buffer[l_child];
				buffer[l_child] = buffer[pos];
				buffer[pos] = temp;
				pos = l_child;
			}
			else break;
		else if (buffer[r_child] < buffer[pos]) {
			auto temp = buffer[r_child];
			buffer[r_child] = buffer[pos];
			buffer[pos] = temp;
			pos = r_child;
		}
		else break;
	}
	return output;
}

template<class T, int MaxSize>
void MinHeap<T, MaxSize>::clear() {
	_size = 0;
}


template<class T, int MaxSize>
bool MinHeap<T, MaxSize>::empty()const {
	return _size ? false : true;
}

template<class T, int MaxSize>
bool MinHeap<T, MaxSize>::full()const {
	return _size == MaxSize ? true : false;
}

template<class T, int MaxSize>
int MinHeap<T, MaxSize>::size()const {
	return _size;
}

template<class T, int MaxSize>
int MinHeap<T, MaxSize>::max_size()const {
	return MaxSize;
}

//_MINHEAP_END

_OC_END

#endif
透小犹
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++类模板
weixin_41528527的博客
07-10 143
类模板定义 类模板由模板说明和类说明构成 模板说明同函数模板，如下： template <类型形式参数表> 类声明 例如： template class ClassName { //ClassName 的成员函数 private ： Type DataMember; } 类模板与函数模板的定义和使用类似，有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，我们可以通过如下面语句声明了一个类模板： template <typename T> class A { publ
C++模板类简介
mal327的专栏
04-13 903
C++模板类简介    模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，  从而实现了真正的代码可重用性。模版可以分为两类，一个是函数模版，另外一个是类模版。   1.  模板的概念。  我们已经学过重载(Overloading)，对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如，为求两个数的最大值，我们定义
C++ 笔记：N例类模板+内存管理
Qiuery的博客
09-06 348
前言：经过改善单例类模板，再通过内存管理实现的N例类模板，测试没有问题，功能算是达标，实际项目工程使用有待考究。 #include &lt;string&gt; #include &lt;iostream&gt; #include &lt;cstdlib&gt; using namespace std; //N例类模板 template &lt; typename T &gt; clas...
深入理解C++中的堆：从基本概念到实际应用
Lion_Long的博客
05-13 1225
堆是一种具有树形结构的数据结构，它遵循堆属性，即：每个节点必须小于其每个子节点。“堆”这个名字可能来自于这样一个事实：如果堆放一堆东西并希望它能保持平衡，人类更愿意把大的东西放在底部，小的东西放在顶部：请注意，这与包含动态分配对象的内存区域中的堆完全无关（与栈相对，栈也是一种数据结构的名称）。堆的一个最重要的特性是，其最小元素位于其根部，易于访问。在堆中，每个节点理论上可以有任意数量的子节点。但在STL中，堆的节点有两个子节点，因此在本文中将用堆来指代二叉堆。
c++练习之模板类的练习
weixin_30892987的博客
07-19 311
编写一维数组模板。可以无限扩展，任意数据类型，可以进行插入，删除，查找，排序等操作 #include<iostream> using std::cout; using std::cin; using std::endl; template <class T> class CTest { public: CTest(T *p,int a):n(a...
c++模板类堆栈
weixin_30329623的博客
02-25 128
#ifndef __MyConsole__Stack__ #define __MyConsole__Stack__ #include <iostream> template<class T> class Stack{ public: explicit Stack(int size); ~Stack(); bool Is...
实验一（模板类操作）
weixin_39725937的博客
10-11 408
一、实验思路 首先建立一个头文件，头文件里建立一个类，包括对象初始化、增、删、查、显示等操作函数声明和一个数组、一个整型表示数组长度。然后建立一个SeqList.cpp文件，里面包含各种函数的定义。最后建立一个主函数对各个函数进行测试。 二、源代码 #ifndef SeqList_H #define SeqList_H const int MaxSize=100; template cl
ACM-ACM竞赛常用模板-C++.zip
03-04
《ACM竞赛常用模板——C++深度解析》 在信息技术领域，ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest，简称ACM/ICPC）是一项极具影响力的编程比赛，旨在激发学生对计算机科学的...
C++小顶堆的类模板实现
03-03
C++小顶堆的实现，其中用到了类模板的知识，代码附有详细注释，主函数中附上了测试代码。欢迎私信讨论！
数据结构-C++实现.zip
最新发布
06-17
在"数据结构-C++实现.zip"这个压缩包中，可能包含了上述各种数据结构的C++实现代码，例如`ljg_resource1`可能是一个源文件，包含了具体的数据结构和算法实现。通过学习和理解这些代码，可以深入掌握数据结构与算法，...
C++ 类模板案例实践
03-12
实现一个通用的数组类，要求如下： * 可以对内置数据类型以及自定义数据类型的数据进行存储 * 将数组中的数据存储到堆区 * 构造函数中可以传入数组的容量 * 提供对应的拷贝构造函数以及operator=防止浅拷贝问题 * ...
基于C++实现的ACM-ACM竞赛常用模板
03-22
这个“基于C++实现的ACM竞赛常用模板”是一个集成了ACM比赛常见问题解决方案的代码库，可以帮助参赛者快速理解和解决各种竞赛题目。 首先，模板通常包括基础数据结构和算法的实现，例如： 1. **排序算法**：快速...
c++最大堆的实现
可乐小浣熊
08-29 1113
     在看一些开源组件的源码时，会发现很多的底层地方都会使用到最大堆（最小堆）的数据结构，如 在libevent中维护超时事件就用到了最小堆的结构，可见，这种数据结构的重要性。      最大堆：根结点的键值是所有堆结点键值中最大者。      最小堆：根结点的键值是所有堆结点键值中最小者。      堆，最重要的一个过程就是重建的过程，当有新的数据加进来或者移除时，都会对堆进行一次重建...
最大堆、最小堆定义及其C++代码实现
YQMind的博客
11-06 2649
很棒的资料https://blog.csdn.net/guoweimelon/article/details/50904346 定义 堆首先必须是一棵完全二叉树 最大堆：完全二叉树，父节点的值不小于子节点的值 最小堆：完全二叉树，父节点的值不大于子节点的值 用数组存储上图所示的最大堆 对于下标为i(1≤i≤n)i (1 \leq i \leq n)i(1≤i≤n)的节点： 父节点：i/2i/2i...
堆的c++类模板实现
qq_61278538的博客
12-10 199
我是新手，这个纯属练手，错误勿喷。 #ifndef HEAP_H #define HEAP_H #include<iostream> /*这是一个用模板实现的堆类，支持各种数据类型*/ //如果你要用这个堆存放其他类的对象，请重载>和<，大于号和小于号 template <class T> class heap { public: //构造函数，默认的最大堆容量是100，第四个参数是设置最大堆还是最小堆的 //默认min==true是最小堆 h
c++堆详解【附代码】
Yoyo的博客
08-24 961
堆是一种重要的数据结构，它具有高效的插入和删除操作，并广泛应用于各种算法和数据结构中。最大堆和最小堆是堆的两种常见类型，它们可以使用数组实现。通过堆，我们可以轻松地获取最大或最小的元素，并且堆排序是一种高效的排序算法。在计算机科学中，堆（Heap）是一种常见的数据结构，用于动态分配内存和管理数据。本文将详细介绍堆的概念、原理、实现方式以及在C++中的应用，并提供相关的代码示例。根据堆属性的不同，我们可以将堆分为最大堆和最小堆。而在最小堆中，父节点的值小于等于其子节点的值。堆可以使用数组或链表来实现。
【堆】C++下定义通用的堆模板
初见还是重逢的博客
03-07 716
程序员在写程序时，最常遇到的就是排序问题 对于N个待排序的数据结构，使用冒泡插入等排序方法，时间复杂度为O(N2)，往往不能满足要求，因此需要使用更加高效的排序方法（归并，二分等）将时间复杂度降低为O(logN) 因此，本文在这里介绍堆排序的方法，与堆的通用数据结构代码，以供参考 部分基础知识 什么是堆？ 定义：堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 要点1：堆可以类比为完全二叉树 要点2：父亲节点的键值或索引总是小于（或者大于）左.
dijkstra算法c++类模板实现
05-25
以下是Dijkstra算法的C++类模板实现，可以适用于任何具有权重边的图（有向或无向）： ```c++ #include <iostream> #include <vector> #include <queue> #include <limits> template <typename T> class Dijkstra { private: std::vector<std::vector<std::pair<int, T>>> graph; // 存储图的邻接表 std::vector<T> dist; // 存储每个顶点的最短距离 std::vector<int> prev; // 存储每个顶点在最短路径中的前驱结点 const T INF = std::numeric_limits<T>::max(); // 无穷大 public: Dijkstra(const std::vector<std::vector<std::pair<int, T>>>& g) : graph(g) {} void run(int start) { int n = graph.size(); dist.assign(n, INF); prev.assign(n, -1); // 使用小根堆存储每个顶点的最短距离及其编号 std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int>>, std::greater<>> pq; pq.emplace(0, start); dist[start] = 0; while (!pq.empty()) { auto [d, u] = pq.top(); pq.pop(); // 如果当前节点已经被处理过，就直接跳过 if (dist[u] < d) { continue; } // 遍历当前节点所有的邻居节点 for (auto [v, w] : graph[u]) { T newDist = dist[u] + w; if (newDist < dist[v]) { dist[v] = newDist; prev[v] = u; pq.emplace(newDist, v); } } } } // 获取从起点到终点的最短距离 T getDistance(int end) const { return dist[end]; } // 获取从起点到终点的最短路径 std::vector<int> getPath(int end) const { std::vector<int> path; for (int u = end; u != -1; u = prev[u]) { path.push_back(u); } std::reverse(path.begin(), path.end()); return path; } }; ``` 使用示例： ```c++ int main() { // 构建有向图 int n = 5; std::vector<std::vector<std::pair<int, int>>> graph(n); graph[0].emplace_back(1, 10); graph[0].emplace_back(3, 5); graph[1].emplace_back(2, 1); graph[1].emplace_back(3, 2); graph[2].emplace_back(4, 4); graph[3].emplace_back(1, 3); graph[3].emplace_back(2, 9); graph[3].emplace_back(4, 2); // 运行Dijkstra算法 Dijkstra<int> dijkstra(graph); dijkstra.run(0); // 输出结果 for (int i = 0; i < n; i++) { std::cout << "Distance from 0 to " << i << ": " << dijkstra.getDistance(i) << std::endl; auto path = dijkstra.getPath(i); std::cout << "Path from 0 to " << i << ": "; for (int u : path) { std::cout << u << " "; } std::cout << std::endl; } return 0; } ``` 输出结果： ``` Distance from 0 to 0: 0 Path from 0 to 0: 0 Distance from 0 to 1: 8 Path from 0 to 1: 0 3 1 Distance from 0 to 2: 9 Path from 0 to 2: 0 3 1 2 Distance from 0 to 3: 5 Path from 0 to 3: 0 3 Distance from 0 to 4: 7 Path from 0 to 4: 0 3 4 ```
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值