大堆和小堆的实现

最新推荐文章于 2024-09-09 17:38:55 发布
最新推荐文章于 2024-09-09 17:38:55 发布
阅读量495 收藏 2
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZWE7616175/article/details/79128286
版权

堆的概念

如果有一个关键码的集合，将这个集合中的所有元素按照完全二叉树的顺序存储在一个一维数组中，并满足最小堆或最大堆的性质。

最小堆：任一结点的关键码均小于等于它的左右孩子的关键码，其中堆顶的元素最小。（任一路径中的元素降序排列）

最大堆：任一结点的关键码均大于等于它的左右孩子的关键码，其中堆顶的元素最大。（任一路径中的元素升序排列）

一、堆的创建（以最小堆为例）

堆的创建按照完全二叉树创建，底层是vector结构，存储的时候按照完全二叉树创建，从倒数第一个叶子结点开始到根结点对当前堆进行向下调整。

//创建最小堆--->时间复杂度O(Nlog2N)
	Heap(const T* array, size_t size)
	{
		//将数组中的元素存起来，按照完全二叉树
		for (size_t i = 0; i < size; ++i)
		{
			_array.push_back(array[i]);
		}
		_array.resize(size);//底层用vector搭载，插入元素后调整vector的大小
		
		//找完全二叉树中倒数第一个非叶子结点
		int Root = (size - 2) >> 1;
		for (; Root >= 0; Root--)
			_Adjustdown(Root);//向下调整，从第一个非叶子结点到根结点调整
	}

二、堆的插入

堆的插入在以建成的最小堆的后面插入，插入后，有可能破坏了堆的结构，从第一个非叶子结点的位置开始到根节点，对当前堆进行向上调整。

//插入元素
	void Insert(const T& data)
	{
		_array.push_back(data);
		int size = _array.size();

		int Root = (size - 2) >> 1;
		for (; Root >= 0; Root--)
			_Adjustup(Root);//向上调整，从第一个非叶子结点到根结点调整
	}

三、堆的删除

堆的删除是删除堆顶元素。

方法一：删除堆顶元素后，将堆中的其他元素向前搬移，但可行性差，调整次数多，可能破坏了堆的性质。

方法二：堆中最后一个元素与堆顶元素进行替换，删除最后一个元素，从堆顶开始，对堆进行向下调整。

//删除元素
	void Delete()
	{
		//堆为空
		if (_array.empty())
			return;

		//堆中含有一个元素,直接删除
		else if (_array.size() == 1)
		{
			_array.pop_back();
			return;
		}

		//堆中含有多个元素
		else
		{
			//1.将最后一个元素与堆顶元素交换
			int size = _array.size();
			swap(_array[0], _array[size - 1]);

			//2.删除最后一个元素
			if (!_array.empty())
				_array.pop_back();

			//3.从堆顶开始，向下调整
			int Root = (size - 2) >> 1;//找完全二叉树中倒数第一个非叶子结点
			for (; Root >= 0; Root--)
				_Adjustdown(Root);
		}
	}

封装调整函数

//向下调整
	void _Adjustdown(size_t pRoot)
	{
		size_t parent = pRoot;
		size_t child = parent * 2 + 1;//默认左孩子为左右孩子中最小的结点
		size_t size = _array.size();//计算堆中元素的个数

		//找出左右孩子中最小的结点
		if ((child + 1 < size) && (_array[child] > _array[child + 1]))//首先需要保证右孩子存在
			swap(_array[child], _array[child + 1]);

		while (child < size)
		{
			if (_array[child] < _array[parent])
			{
				swap(_array[child], _array[parent]);
				parent = child;//继续向下走
				child = parent * 2 + 1;
			}
			else
				break;
		}
	}

	//向上调整
	void _Adjustup(size_t pRoot)
	{
		size_t parent = pRoot;
		size_t child = parent * 2 + 1;//默认左孩子为最小孩子
		size_t size = _array.size();

		if ((child + 1 < size) && (_array[child] > _array[child + 1]))
			swap(_array[child], _array[child + 1]);

		while (child > 0)
		{
			parent = (size - 2) >> 1;
			if (_array[parent] > _array[child])
			{
				swap(_array[parent], _array[child]);
				child = parent;//向上继续
				parent = (child - 1) >> 1;
			}
			else
				break;
		}
	}
但这只是针对于小堆的情况，如何将一个小堆改为大堆呢？

利用仿函数来实现

template <class T>
struct Less
{
	bool operator()(const T& left, const T& right)
	{
		return left < right;
	}
};
template <class T>
struct Greater
{
	bool operator()(const T& left, const T& right)
	{
		return right < left;
	}
};

template <class T,class Compare=Less<T>>
class Heap
{
public:
	Heap()
		:_array(NULL)
	{}

	//创建最小堆--->时间复杂度O(Nlog2N)
	Heap(const T* array, size_t size)
	{
		//将数组中的元素存起来，按照完全二叉树
		for (size_t i = 0; i < size; ++i)
		{
			_array.push_back(array[i]);
		}
		_array.resize(size);//底层用vector搭载，插入元素后调整vector的大小

		//找完全二叉树中倒数第一个非叶子结点
		int Root = (size - 2) >> 1;
		for (; Root >= 0; Root--)
			_Adjustdown(Root);//向下调整，从第一个非叶子结点到根结点调整
	}

	//插入元素
	void Insert(const T& data)
	{
		_array.push_back(data);
		int size = _array.size();

		int Root = (size - 2) >> 1;
		for (; Root >= 0; Root--)
			_Adjustup(Root);//向上调整，从第一个非叶子结点到根结点调整
	}

	//删除元素
	void Delete()
	{
		//堆为空
		if (_array.empty())
			return;

		//堆中含有一个元素,直接删除
		else if (_array.size() == 1)
		{
			_array.pop_back();
			return;
		}

		//堆中含有多个元素
		else
		{
			//1.将最后一个元素与堆顶元素交换
			int size = _array.size();
			swap(_array[0], _array[size - 1]);

			//2.删除最后一个元素
			if (!_array.empty())
				_array.pop_back();

			//3.从堆顶开始，向下调整
			int Root = (size - 2) >> 1;//找完全二叉树中倒数第一个非叶子结点
			for (; Root >= 0; Root--)
				_Adjustdown(Root);
		}
	}

private:
	//向下调整
	void _Adjustdown(size_t pRoot)
	{
		size_t parent = pRoot;
		size_t child = parent * 2 + 1;//默认左孩子为左右孩子中最小的结点
		size_t size = _array.size();//计算堆中元素的个数

		//找出左右孩子中最小的结点（小堆）/最大的结点（大堆）
		if ((child + 1 < size) && Compare()(_array[child+1],_array[child]))//首先需要保证右孩子存在
			swap(_array[child], _array[child + 1]);

		while (child < size)
		{
			if (Compare()(_array[child], _array[parent]))
			{
				swap(_array[child], _array[parent]);
				parent = child;//继续向下走
				child = parent * 2 + 1;
			}
			else
				break;
		}
	}

	//向上调整
	void _Adjustup(size_t pRoot)
	{
		size_t parent = pRoot;
		size_t child = parent * 2 + 1;//默认左孩子为最小孩子
		size_t size = _array.size();

		if ((child + 1 < size) && Compare()(_array[child + 1], _array[child]))
			swap(_array[child], _array[child + 1]);

		while (child > 0)
		{
			parent = (size - 2) >> 1;
			if (Compare()(_array[child],_array[parent]))
			{
				swap(_array[parent], _array[child]);
				child = parent;//向上继续
				parent = (child - 1) >> 1;
			}
			else
				break;
		}
	}

private:
	vector<T> _array;
};
也改为模板的模板参数 

template <class T>
struct Less
{
	bool operator()(const T& left, const T& right)
	{
		return left < right;
	}
};
template <class T>
struct Greater
{
	bool operator()(const T& left, const T& right)
	{
		return right < left;
	}
};

template <class T, template<class> class Compare=Less>
class Heap
{
public:
	Heap()
		:_array(NULL)
	{}

	//创建最小堆--->时间复杂度O(Nlog2N)
	Heap(const T* array, size_t size)
	{
		//将数组中的元素存起来，按照完全二叉树
		for (size_t i = 0; i < size; ++i)
		{
			_array.push_back(array[i]);
		}
		_array.resize(size);//底层用vector搭载，插入元素后调整vector的大小

		//找完全二叉树中倒数第一个非叶子结点
		int Root = (size - 2) >> 1;
		for (; Root >= 0; Root--)
			_Adjustdown(Root);//向下调整，从第一个非叶子结点到根结点调整
	}

	//插入元素
	void Insert(const T& data)
	{
		_array.push_back(data);
		int size = _array.size();

		int Root = (size - 2) >> 1;
		for (; Root >= 0; Root--)
			_Adjustup(Root);//向上调整，从第一个非叶子结点到根结点调整
	}

	//删除元素
	void Delete()
	{
		//堆为空
		if (_array.empty())
			return;

		//堆中含有一个元素,直接删除
		else if (_array.size() == 1)
		{
			_array.pop_back();
			return;
		}

		//堆中含有多个元素
		else
		{
			//1.将最后一个元素与堆顶元素交换
			int size = _array.size();
			swap(_array[0], _array[size - 1]);

			//2.删除最后一个元素
			if (!_array.empty())
				_array.pop_back();

			//3.从堆顶开始，向下调整
			int Root = (size - 2) >> 1;//找完全二叉树中倒数第一个非叶子结点
			for (; Root >= 0; Root--)
				_Adjustdown(Root);
		}
	}

private:
	//向下调整
	void _Adjustdown(size_t pRoot)
	{
		size_t parent = pRoot;
		size_t child = parent * 2 + 1;//默认左孩子为左右孩子中最小的结点
		size_t size = _array.size();//计算堆中元素的个数

		//找出左右孩子中最小的结点（小堆）/最大的结点（大堆）
		if ((child + 1 < size) && Compare<T>()(_array[child + 1], _array[child]))//首先需要保证右孩子存在
			swap(_array[child], _array[child + 1]);

		while (child < size)
		{
			if (Compare<T>()(_array[child], _array[parent]))
			{
				swap(_array[child], _array[parent]);
				parent = child;//继续向下走
				child = parent * 2 + 1;
			}
			else
				break;
		}
	}

	//向上调整
	void _Adjustup(size_t pRoot)
	{
		size_t parent = pRoot;
		size_t child = parent * 2 + 1;//默认左孩子为最小孩子
		size_t size = _array.size();

		if ((child + 1 < size) && Compare<T>()(_array[child + 1], _array[child]))
			swap(_array[child], _array[child + 1]);

		while (child > 0)
		{
			parent = (size - 2) >> 1;
			if (Compare<T>()(_array[child], _array[parent]))
			{
				swap(_array[parent], _array[child]);
				child = parent;//向上继续
				parent = (child - 1) >> 1;
			}
			else
				break;
		}
	}

private:
	vector<T> _array;
};

ZWE7616175
关注
专栏目录
大小堆的实现（C++）
u014524930的博客
03-02 5754
过了一段时间了，还是记录一下，最近感觉记忆力下降的很快啊。大小堆的构造首先得知道大小堆是个什么，大小堆是一种二叉树，它的要求比起平衡树来说是简单一些的，只有一个，就是所有父节点必须大于自己的子节点，但是没有什么左孩子必须小于右孩子这种。到这里其实大小堆的作用很容易看出，最大堆就是根节点最大，最小堆就是根节点最小，可以用于排序。作为测试，这里使用整形数组作为初始化数据，二叉树可以直接使用c++单循环...
聊聊 Java 数据结构与算法中的堆最小堆和最大堆
Huangjiazhen711的博客
09-05 550
堆的数据结构有很多种体现形式，包括；2-3堆、B堆、斐波那契堆，而在 Java API 中最常用的是用于实现优先队列的二叉堆，它是由 JWJ Williams 在 1964 年引入的，作为堆排序算法的数据结构。另外在 Dijkstra 算法等几种高效的图算法中，堆也是非常重要的。堆的实现在 Java API 中主要体现在延迟队列的实现二叉堆上，这里小傅哥单独把这部分代码拆分出来，了解下关于小堆和大堆的实现。从对堆的数据结构介绍上可以看到，小堆和大堆的唯一区别仅是对元素的排序方式不同。
小堆的实现
qq_55143256的博客
12-17 226
1.头函数 #pragma once typedef int HPDataType; typedef struct Heap { HPDataType* a; int size; int capacity; }Heap; int (*com)(int a, int b); //函数指针的尝试,用com1函数和com2函数作为一次尝试 //int Comp1(int a, int b); //a比b大则返回1,否则返回0 //int Comp2(int a, int b); //a比b大则返回
数据结构--大根堆小根堆
最新发布
分享技术，分享经验
09-09 1057
堆是一种优先级队列实现，通常用于高效地找出最值（最大或最小值）。堆的每个父节点都和其子节点满足一定的关系。是堆调整操作的核心，用来维护堆的性质。是堆（Heap）数据结构的两种类型，它们都是。个元素，这些元素在数组中的索引是从。堆可以使用数组来实现，这是由于堆的。假设堆中某个节点位于数组的索引。最小堆（又称：小根堆，小顶堆）最大堆（又称：大根堆，大顶堆）结构具备的特性使得它可以。映射到一个一维数组中。
【数据结构】堆 -- 大堆小堆
m0_64645696的博客
02-01 3073
堆的物理结构其实是数组，逻辑结构则是二叉树。 堆的调整算法有多种，其中典型的是：大堆 和 小堆。 小堆的意思就是：父亲位，比孩子位，要小； 大堆：父亲位，比孩子位，要大。 下面我们来用图说明： 给一组数组：int a[] = { 27,15,19,18,28,34,65,49,25,37 }; 按照小堆的方式来排序： 由于我们父亲的两个孩子位都是小堆排序，所以我们可以直接从头开始进行一次排序即可。 #include <stdio.h> void Swap(int* pa,
大小堆实现
景初浅行
03-24 426
#include #include #include #include using namespace std; template class Heap { protected: vector _a; //一维数组 //void _AdjustDown(int root) //下调,构建大堆 //{ // int parent = root; // i
C语言实现基于最大堆和最小堆的堆排序算法示例
09-02
通过`initHeap`函数，我们可以遍历这些节点并调用`adjustMaxHeap`函数，确保每个节点都满足最大堆的性质。`adjustMaxHeap`函数通过比较父节点和子节点的值，如果子节点大于父节点，就交换它们的位置，然后递归地检查...
Java语言实现最大堆代码示例
08-28
Java语言实现最大堆代码示例 在计算机科学中，堆是一种特殊的树形数据结构，最...最大堆是一种非常重要的数据结构，Java语言中可以使用数组来实现最大堆，需要注意实现最大堆的关键点，例如维护堆的性质和时间复杂度。
解读堆排序算法及用C++实现基于最大堆的堆排序示例
12-25
1、堆排序定义 ...【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如最小堆示例和最大堆示例所示。 堆排序算法 2、
Golang实现最大堆/最小堆
qq_42139963的博客
10-17 2294
Golang实现最大堆/最小堆 参考： https://yangjiahao106.github.io/2019/01/15/golang-%E6%9C%80%E5%A4%A7%E5%A0%86%E5%92%8C%E6%9C%80%E5%B0%8F%E5%A0%86/ https://studygolang.com/articles/24288 方法一 此方法就是比较传统、常见的方法，下面来构建一个最小堆： type Heap struct { Size int Elems []int } fun
最大堆和最小堆
qq_61941868的博客
10-27 2259
数据结构 最大堆 最小堆
大小堆的算法例子
08-08
用C++的模板的形式实现小堆算法
最大（小）堆Java实现
05-24
代码只是实现了最大堆的顺序存储，插入，删除，筛选建立
最大堆、最小堆详解
JKerving的博客
10-16 9607
最大堆、最小堆详解 Overview 最大堆和最小堆是二叉堆的两种形式。二叉堆(binary heap)是一种特殊的堆，二叉堆是完全二叉树或者是近似完全二叉树。二叉堆满足堆特性：父节点总是保持固定的序关系于任何一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆。 文章目录最大堆、最小堆详解Overview一、二叉堆二、最大堆、最小堆详解(以最大堆为例)由上至下的下沉建堆操作(以最大堆为例)...
堆排序（大顶堆、小顶堆）
三冬暖
10-05 844
例如下图：父节点比它的子节点都要大的完全二叉树就是大顶堆。（左右孩子的大小就没有顺序）相反，父节点比字节点都小的完全二叉树是小顶堆（左右孩子的大小就没有顺序）
【数据结构】大小堆的实现及堆排序
shangguan_1234的博客
10-11 482
堆一般指二叉堆，结构如下 圈内数字指下标，圈外为内容，如图现在并不能称为一个堆，因为它并不满足大堆也不满足小堆的组成，下面介绍大堆和小堆的简答介绍和实现 大堆是指每个父节点的数都大于自己的每个孩子节点的值 用到的算法是让大数上移循环至完成大堆 void Adjustup(size_t child) { Compare com; size_t parent =(child
大小堆的实现与实现优先级队列
L_XRUI的博客
12-31 1094
堆：可视为一棵完全二叉树结构，最小堆每个父节点都小于孩子结点，最大堆每个父节点都大于孩子结点。 建堆思想：实现向下调整算法AdjustDown()：即当一个节点的左子树和右子树都已为最大堆或最小堆（在这里则寻找树倒着走的第一个非叶子结点，依次进行调整），比较其左右孩子结点满足大堆或小堆要求的节点，再与此节点比较，若孩子结点大，满足大堆交换两节点值，或小堆，孩子结点小则交换。大堆与小堆思想基本相同
12、最大堆和最小堆 的实现(下篇)
沿海奔跑的少年
03-30 228
一、简单介绍 1、我们前面已经用最大堆得例子，已经讲了所有的最大堆的操作。 里面包过添加操作，用到我们shiftUp()操作。 包过删除操作，我们用到sihftDown操作。 然后就是通过一个数组，我们能够构建一个堆。也就是我们说的heapify 操作。 2、最小堆的操作和上面的类似，只是比较的时候不一样。 二、所有的代码实现 1、最大堆的实现 package com.ipp.d...
Java堆排序详解：大顶堆与小顶堆实现
"本文主要介绍了Java中的堆排序算法，包括大顶堆和小顶堆的概念及其实现。堆排序是一种基于比较的排序算法，其时间复杂度为Ο(nlogn)。通过构建和调整堆来实现排序过程。" 在计算机科学中，堆排序是一种高效的排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值