大小堆&&堆排序&&堆的应用

最新推荐文章于 2023-10-05 19:54:45 发布
最新推荐文章于 2023-10-05 19:54:45 发布
阅读量1.2k 收藏 6
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/IT_iverson/article/details/79009501

一.首先说一下堆的概念吧这里就不按照标准的概念来说了，就说说我理解的堆。

堆就是一个数组中的元素，参考着完全二叉树的这种数据结构存储在数组中，这样就是一个堆。注意：这里是参考，实际的存储还是在数组中，只不过数组中的存储顺序满足完全二叉树而已。说到堆离不开大小堆，下面继续介绍大小堆的概念。

1.最小堆：因为数组中的元素是参考完全二叉树的存储顺序存储的，所以小堆就是每一个双亲结点的值都<=左右孩子的值，堆顶的元素是最小值


2.最大堆：任何一个双亲结点的值都大于等于左右孩子的值，并且堆顶元素的值是最大值。


二.下面来说说如何创建一个堆，因为堆离不开最大堆和最小堆，所以我这里创建的堆是生成了自动生成了最小堆，首先给出代码，然后在给出代码解释：

#include<iostream>
#include<vector>
using namespace std;
template<class T>
class Heap//堆
{
public:
	Heap(T* array, size_t size)//构造函数
		:_size(size)
	{
		_array.resize(size);
		for (size_t i = 0; i < _size; i++)
		{
			_array[i] = array[i];
		}
		_AdjustDown((_size - 2) >> 1);
	}
	T top() const//返回堆顶的元素
	{
		T a = _top();
		return a;
	}
	void Push(const T& data)//给堆中插入元素,使用向上调整插入
	{
		_Push(data);
	}
	void Pop()//删除堆中的元素其实就是删除堆顶的元素
	{
		_Pop();
	}
private:
	void _AdjustDown(int parent)//从上往下调整，建立小堆
	{
		for (int i = parent; i >= 0; i--)
		{
			parent = i;
			size_t child = parent * 2 + 1;
			while (child<_size)
			{
				if (child + 1 < _size&&_array[child] > _array[child + 1])
					child += 1;
				if (/*child<_size&&*/_array[parent] > _array[child])
				{
					swap(_array[parent], _array[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
	}
	void _AdjustUp(size_t child)//向上调整,插入中使用
	{
		size_t parent = (child - 1) >> 1;
		while (child > 0)
		{
			if (_array[parent] > _array[child])
			{
				swap(_array[parent], _array[child]);
				child = parent;
				parent = (child - 1) >> 1;
			}
			else
				break;
		}
	}
	T _top() const
	{
		return _array[0];
	}
	void _Push(const T data)//堆中插入元素
	{
		_array.push_back(data);
		_size++;
		if (_array.size() > 1)
		{
			_AdjustUp(_size - 1);
		}
	}
	void _Pop()//删除堆顶元素
	{
		if (_array.empty())
			return;
		size_t last = _size - 1;
		swap(_array[0], _array[last]);
		_array.pop_back();
		_size--;
		if (_size > 1)
		{
			_AdjustUp(0);
		}
	}
private:
	vector<T> _array;
	size_t _size;
};
int main()
{
	int array[] = { 53, 17, 78, 9, 45, 65, 87, 23 };
	Heap<int> s(array, sizeof(array) / sizeof(*array));
	s.Push(1);
	s.Pop();
	cout << s.top() << endl;
	system("pause");
	return 0;
}
上面是整体所有的代码下面给出解析：

1.创建堆（自动生成最小堆）

Heap(T* array, size_t size)//构造函数
		:_size(size)
	{
		_array.resize(size);
		for (size_t i = 0; i < _size; i++)
		{
			_array[i] = array[i];
		}
		_AdjustDown((_size - 2) >> 1);
	}
这段代码就不需要我多说了吧，将数组中的元素保存在容器vector中，下面我来终点介绍这段代码：即得出最小堆的方法--->向下调整法
_AdjustDown((_size - 2) >> 1);


注意想要生成最小堆的方法是向下调整法，并不是说要生成最大堆就用向上调整法，想要生成最大堆，只需要将其中比较的顺序符号反过来就可以了。而向上调整法是给堆中插入元素时使用的。

2.下面我来说说向上调整法



3.好了关于堆最核心的两个算法已经讲完了，剩下的就是一下很简单的东西了，下面我来说说关于堆的删除即Pop()

void _Pop()//删除堆顶元素
	{
		if (_array.empty())
			return;
		size_t last = _size - 1;
		swap(_array[0], _array[last]);
		_array.pop_back();
		_size--;
		if (_size > 1)
		{
			_AdjustUp(0);
		}
	}
算法核心就是将堆顶元素和最后一个元素互换，然后剔除互换后的最后一个元素（即要删除的元素），在重新调整堆就好了。

到这里关于堆的一些问题就讲完了置于剩下的那几个功能都很简单自己去看就可以了。测试代码我在最开是的代码中也已经给出了自己去测试就可以了。

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////虽然上面 的堆已经说完了但是美中不足的是，每次我创建的总是最小堆，要是我想创建最大难道每次都要去将其中的符号改动吗？当然不需要，下面我就来说说升级版本的，这个版本中加入了仿函数，使一切看起就变得很简单了

1.首先说一下什么是仿函数

其实就是在你定义的类中重载()，实现一个具体的功能，然后这个类对象就可以当成函数调用了！

举个简单的例子：

template<class T>
class Add//定义具有加法功能的仿函数
{
public:
	int operator()(const T& a, const T& b)
	{
		int  sum;
		sum = a + b;
		return sum;
	}
};
template<class T>
class Mul//定义具有乘法功能的仿函数
{
public:
	int operator()(const T& a, const T& b)
	{
		int  sum;
		sum = a*b;
		return sum;
	}
};
template<class T,class CA>//在这里只是多了个参数而已
class Caculate
{
private:
	int a;
	int b;
public:
	Caculate(int x, int y)
		:a(x)
		, b(y){}
	CA s;//仿函数类的对象
	int jisuanqi()
	{
		return s(a,b);//把对象当成函数调用
	}
};
int main()
{
	Caculate<int,Add<int>> s(10, 10);//在这里你向进行什么运算取决于你传过去的是哪个对象
	cout << s.jisuanqi() << endl;//执行加法运算
	system("pause");
	return 0;
}
上面就是一个简单的仿函数的应用。如果有不理解的地方私我。

下面来说说把仿函数应用到堆中的改造方法，因为最大小堆的建立就是取决于如下语句

if (child + 1 < _size&&com(_array[child+1], _array[child]))
					child += 1;
				if (child<_size&&com(_array[child],_array[parent]))
				{
					swap(_array[parent], _array[child]);
					parent = child;
					child = parent * 2 + 1;
				}
所以我们可以将判断的if语句中的表达式交给仿函数去完成，我们在if里面只需要调用仿函数就可以了，所以产生如下的仿函数 

template<class T>
class Less//建立小堆的仿函数
{
public:
	bool operator()(const T& left, const T& right)
	{
		return left < right;
	}
};
template<class T>
class Greater//建立大堆的仿函数
{
public:
	bool operator()(const T& left, const T& right)
	{
		return left >right;
	}
};
使用方法如下

下面给出全部代码：

#include<iostream>
#include<vector>
using namespace std;
//1.函数指针可以实现
//2.仿函数
template<class T>
class Less
{
public:
	bool operator()(const T& left, const T& right)
	{
		return left < right;
	}
};
template<class T>
class Greater
{
public:
	bool operator()(const T& left, const T& right)
	{
		return left >right;
	}
};
//这里创建的都是小堆
template<class T,class Compare=Less<int>>
class Heap//堆
{
public:
	Heap(T* array, size_t size)
		:_size(size)
	{
		_array.resize(size);
		for (size_t i = 0; i < _size; i++)
		{
			_array[i] = array[i];
		}
		_AdjustDown((_size - 2) >> 1);
	}
	T top() const//返回堆顶的元素
	{
		return _array[0];
	}
	void Push(const T& data)//给堆中插入元素,使用向上调整插入
	{
		//方法1，直接尾插
		_array.push_back(data);
		_size++;
		if (_array.size() > 1)
		{
			_AdjustUp(_size - 1);
		}
	}
	void Pop()//删除堆中的元素其实，就是删除堆顶的元素
	{
		if (_array.empty())
			return;
		size_t last = _size - 1;
		swap(_array[0], _array[last]);
		_array.pop_back();
		_size--;
		if (_size > 1)
		{
			_AdjustDown(0);
		}
	}
private:
	void _AdjustDown(int parent)//从上往下调整，建立小堆
	{
		for (int i = parent; i >= 0; i--)
		{
			parent = i;
			size_t child = parent * 2 + 1;
			while (child<_size)
			{
				Compare com;
				if (child + 1 < _size&&com(_array[child+1], _array[child]))
					child += 1;
				if (child<_size&&com(_array[child],_array[parent]))
				{
					swap(_array[parent], _array[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
	}
	void _AdjustUp(size_t child)//向上调整,插入中使用
	{
		size_t parent = (child - 1) >> 1;
		while (child>0)
		{
			if (Compare()(_array[child],_array[parent]))
			{
				swap(_array[parent], _array[child]);
				child = parent;
				parent = (child - 1) >> 1;
			}
			else
				break;
		}
	}
private:
	vector<T> _array;
	size_t _size;//缺点就是每次插入的需要调整
};
int main()
{
	int array[] = { 53, 17, 78, 9, 45, 65, 87, 23 };
	Heap<int,Greater<int>> s(array, sizeof(array) / sizeof(*array));
	/*s._downtoup();*/
	s.Push(1);
	s.Pop();
	cout << s.top() << endl;
	system("pause");
	return 0;
}
因为测试代码我也给出了，所以自行去测试。

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

关于堆的内容说完了，下面说说堆的应用

1.优先级队列

template<class T,class Compare>
class Priority
{
public:
	Priority(){}
	void Push(const T& data)
	{
		_ph.Push(data);
	}
	void Pop()
	{
		_ph.Pop();
	}
	T Top() const
	{
		return _hp.Top();
	}
	bool Empty()const 
	{
		return _hp.Empty();
	}
private:
	Heap<int, Compare> _hp;
};
2.对排序（递增排序）

1.首先建立调整最大堆的的函数

2.将你要排序的数组首先调整一次，生成堆

3.开始排序（交换堆顶和最后一个元素的位置，然后除去最后一个元素，继续调整，一次类推直到全部排序完）

下面给出代码

void Adjustheap(int *array, int size, int parent)//调整堆。调整出来的是大堆
{
	int child = parent * 2 + 1;

	while (child<size)
	{
		if (child+1<size&&array[child]<array[child + 1])
			child += 1;
		if (array[parent] < array[child])
		{
			swap(array[parent], array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;//不需要调整直接结束
	}
}
void HeapSort(int *array, int size)
{
	//创建堆
	int root = (size - 2) >> 1;
	for (; root > 0; --root)
	{
		Adjustheap(array, size, root);//调整堆
	}
	//堆排序
	for (int i = 0; i < size-1;i++)
	{
		swap(array[0],array[size - i - 1]);
		Adjustheap(array, size - i-1, 0);
	}
}
int main()
{
	int array[] = { 5, 3, 2, 4, 1 };
	HeapSort(array, 5);
	system("pause");
	return 0;
}
排序后的数组

3.Topk问题：

即在海量的数据中查找最大或者最小的前 N个数据

1.假如要找前N个最大的数话，首先建立一个元素为N的小堆，然后开始遍历数据，如果数据比堆根大则将堆根pop出去，然后将此元素push进堆，然后继续调整，调整好以后的堆顶是最小的，以此类推，当数据全部扫描完成，则这个堆中的元素就是我们要的数据

2.假如要找前N个最小的数的话，使用最大堆，比堆顶元素小的话pop堆顶,push元素，然后调整堆，直到数据遍历完毕。

以上关于堆的一些内容就介绍完了，希望对大家对于堆的理解有帮助，不懂或出错的地方欢迎留言一起交流学习！

堆的概念（最大堆和最小堆）以及使用堆的实际应用场景
2402_84885073的博客
07-19 1423
然而，在大多数情况下，这种空间利用率的损失是可以接受的，因为堆的主要优势在于其高效的插入、删除和查找最大。首先构建最大堆或最小堆，然后将堆顶元素（最大值或最小值）与堆尾元素交换，并减少堆的大小，再对新的堆顶元素进行下沉操作，重复此过程直到堆的大小为。：堆的物理结构是顺序存储的，即使用数组来表示，且满足完全二叉树的性质，即除了最后一层外，每一层都被完全填满，且所有节点都尽可能地向左侧对齐。：如果某个任务的优先级发生变化，可以在堆中找到该任务节点，调整其值，并重新进行堆的调整（上移或下移），以保持堆的性质。
【数据结构】大小堆的理解，创建，增加和删除元素操作
qq_39487033的博客
10-21 1666
什么是大小堆？ 大小堆是基于完全二叉树的结构； 大堆：任意一个结点的左右孩子的数据都小于此结点的数据，位于堆顶的结点的数据最大。 小堆：任意一个结点的左右孩子的数据都大于此结点的数据，位于堆顶的结点的数据最小。 下面以小堆为例，图解： 以下都是以小堆为例 如何创建小堆？ 首先我们只会得到一个数组，并且我们知道堆最终形态是完全二叉树。通过递归的思想，如果能把最后一个以非叶子结点为根的树变为小堆，然...
大小堆之堆排序
qq_35623393的博客
10-25 595
之前已经说过了好些排序了，今天就说一下最后一个排序，那就是堆排序，但是我们这个堆和内存中的堆还不是一个堆，我们现在所说的大小堆其实是一个树。接下来详细的说一说 先要说堆，那我们还是先说说一些最基础关于树的一些概念，就先说说二叉树好了，因为我们今天用到的就是二叉树，首先二叉树也是一种数据结构，它有父节点和子节点，在二叉树中有2个叶子节点，父节点和第一个子节点的关系一般是2倍的关系；然而堆排序就
堆排序及其应用
木心算法
12-20 889
介绍堆排序及其应用，topk问题，优先级队列等。
希尔排序&快速排序&合并排序&基数排序&堆积树排序
09-05
堆排序算法的过程是首先将待排序的序列构造成一个大顶堆，这样堆的根节点就是整个序列的最大值，然后将根节点与最后一个元素交换，然后对剩下的n-1个元素重复以上操作。堆排序不稳定，具有O(n log n)的时间复杂度，...
堆排序简介及应用实例及实例分析.txt
07-18
### 堆排序简介 堆排序是一种基于比较的排序算法，它利用了二叉堆（通常是最大堆或最小堆）的数据结构特性来进行排序操作。在介绍堆排序之前，我们先来了解一下...在实际应用中，需要根据具体情况选择是否使用堆排序。
堆排序 堆排序新手教程 包含注释和代码
09-26
堆排序适用于大数据量的排序，在实际应用中非常广泛。 在实际编程中，堆排序可以用来解决各种与排序相关的问题，例如求解中位数、优先队列的实现、以及在一些特定的数据结构中进行高效的数据处理。尽管堆排序的最坏...
基于java实现堆排序
最新发布
12-23
例如，在平均情况下，快速排序的常数因子更小，因此在实际应用中可能会比堆排序更快。此外，堆排序并不适合缓存，因为它会访问许多分散的内存地址。由于堆排序在最坏情况下仍能保证O(nlogn)的效率，因此它在需要保证...
堆排序的Java实现最大堆方法HeapSort
09-26
堆排序是计算机科学中一种著名的排序...堆排序算法以其独特的数据结构和高效的性能，在计算机科学和编程领域有着广泛的应用。掌握堆排序及其最大堆的实现，对于任何需要处理排序问题的程序员来说都是至关重要的技能。
大小堆 排序
lianliange85的专栏
11-30 695
 From：Binary Min — Max Heap  and example of heapSort A binary heap is a heap data struc­ture cre­ated using a binary tree. binary tree has two rules - Binary Heap has to be com­plete bi
堆排序（大堆）
不知道起啥名称的博客
05-08 1万+
前言：堆排序可分为大堆和小堆。      其实堆的空间结构实际上就是一棵完全二叉树，不过堆有它自己的限定条件。大堆就是树中每个父亲节点都要比孩子节点大，并且两个兄弟之间是没有大小区分的。小堆与之相反，就是每个父亲节点都要比孩子节点小。    堆的空间结构虽然是个完全二叉树，但是这样的结构也是我们为了好理解才想出来的，实际上堆是通过数组的下标进行相应的排序，因为完全二叉树中的结点的编号可以算出来，这...
堆排序实现及应用
开发之路
09-30 1458
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
最小/大堆的操作及堆排序
weixin_30888413的博客
03-10 324
摘自：《啊哈算法》 我们要用1， 2， 5， 12， 7， 17， 25， 19， 36， 99， 22， 28， 46， 92来建立最小堆，并且删除最小的数，并增加一个数23 如何建立这个堆： //建堆 n = 0; for (int i = 1; i <= m; i++) { n++; h[n] = a[n]; shiftup(n); } ...
堆排序（大小顶推）
qq_61185410的博客
03-18 906
大顶堆：将元素较大的数往上浮，从数组的最后一个根节点往上逐渐堆化，堆化完成后进行第一个元素与最后一个元素值对调这样最大的元素就在数组末尾，缩短末尾，再次调整大顶堆。 import java.util.*; // 1:无需package // 2: 类名必须Main, 不可修改 public class Main { public static void main(String[] args) { Scanner input = new Scanner(System...
堆排序:最大堆与最小堆
jxzly71的博客
09-09 482
将堆生成为完全二叉树 将根节点与最后一个叶节点互换 从第一层开始比较父节点和子节点大小，先比较子节点取大／小，然后与父节点比大／小，如果比父节点大／小，则调换位置 追层往下，结束后重复第2、3步
堆排序（大顶堆、小顶堆）
三冬暖
10-05 2056
例如下图：父节点比它的子节点都要大的完全二叉树就是大顶堆。（左右孩子的大小就没有顺序）相反，父节点比字节点都小的完全二叉树是小顶堆（左右孩子的大小就没有顺序）
jvm堆大小的设置
热门推荐
zfgogo的博客
07-28 4万+
问题引入： -Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3，,其最小内存值和Survivor区总大小分别是（10240m    2048m）； 解析： -Xmx：最大堆大小 -Xms：初始堆大小 -Xmn:年轻代大小 -XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值 年轻代5120m， Eden：...
【数据结构】大小堆的实现及堆排序
shangguan_1234的博客
10-11 512
堆一般指二叉堆，结构如下 圈内数字指下标，圈外为内容，如图现在并不能称为一个堆，因为它并不满足大堆也不满足小堆的组成，下面介绍大堆和小堆的简答介绍和实现 大堆是指每个父节点的数都大于自己的每个孩子节点的值 用到的算法是让大数上移循环至完成大堆 void Adjustup(size_t child) { Compare com; size_t parent =(child
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值