堆的基本实现及优先级队列问题

最新推荐文章于 2022-05-05 17:40:33 发布
最新推荐文章于 2022-05-05 17:40:33 发布
阅读量593 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 c/c++/数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_29503203/article/details/52793946
本文深入讲解堆数据结构的实现原理，包括最大堆和最小堆的构造、元素的增删操作及时间复杂度分析，并探讨了堆在优先级队列中的应用。

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

堆数据结构是一种数组对象，它可以被视为一棵完全二叉树结构。堆结构的二叉树存储有两种：

最大堆：每个父节点的都大于孩子节点；

最小堆：每个父节点的都小于孩子节点。

下来以大堆为例：

1.如何建堆？

1>首先我们选取vector来对堆中元素进行存储;

2>由于堆数据结构可被视为一棵完全二叉树，我们可以从最后一个非叶子节点起往上调整；但是须得注意，这个首先得满足左右子树都是大堆得情况。

3>上调过程中，先让child指向左孩子，然后进行左,右孩子的比较，选出较大的一个，再与父节点比较，如果父节点比两孩子中较大那个值小，则需交换父节点与子节点，直至调整为大堆。


Heap(T* a,size_t size)
{
     assert(a);
     _a.reserve(size);
     for (size_t i=0;i<size;++i)
     {
	_a.push_back(a[i]);
      }

      //建堆，从第一个非叶子节点的父节点开始调整
     for (int i=(size-2)/2;i>=0;--i)   
     {
	AdjustDown(i);
     }
}

void AdjustDown(size_t root)
{
   size_t parent=root;
   size_t child=parent*2+1;   //先让child指向左孩子
   while (child<_a.size())
   {
	//保证右孩子不为空
	if (child+1<_a.size() && _a[child+1]>_a[child])
	{
	   ++child;
	}
	if (_a[parent]<_a[child])
	{
	   std::swap(_a[parent],_a[child]);
	   parent=child;
	   child=parent*2+1;
	}
	else
	   break;
	}
}


2.建好堆后如何在堆中进行push元素？

先将元素插入到数组最后一个位置，然后进行上调操作，直至满足大堆的特点。

3.pop元素？

1>我们采取先将堆中最后一个元素转移至第一个元素位置，也就是用最后一个元素覆盖掉第一个元素；

2>将最后那个pop掉；

3>从0位置处开始往下调整；

4>在向下调整时，需注意找公共父节点parent=(child-1)/2，以及循环条件。


void Pop()
	{
		assert(!_a.empty());
		std::swap(_a[0],_a[_a.size()-1]);
		_a.pop_back();
		AdjustDown(0);
	}
void AdjustUp(size_t child)
	{
		while (child>0)
		{
			size_t parent=(child-1)/2;
			if (_a[parent]<_a[child])
			{
				std::swap(_a[parent],_a[child]);
				child=parent;
			}
			else
				break;
		}
	}


实现大堆的完整代码：

Heap.h

#pragma once

#include<iostream>
#include<assert.h>
#include<vector>
using namespace std;

template<class T>
class Heap
{
public:
	Heap(T* a,size_t size)
	{
		assert(a);
		_a.reserve(size);
		for (size_t i=0;i<size;++i)
		{
			_a.push_back(a[i]);
		}

		//建堆，从第一个非叶子节点的父节点开始调整
		for (int i=(size-2)/2;i>=0;--i)   
		{
			AdjustDown(i);
		}
	}

	void Push(const T& d)
	{
		_a.push_back(d);
		AdjustUp(_a.size()-1);
	}

	void Pop()
	{
		assert(!_a.empty());
		std::swap(_a[0],_a[_a.size()-1]);
		_a.pop_back();
		AdjustDown(0);
	}

	const T& Top()
	{
		assert(!_a.empty());
		return _a[0];
	}

	bool Empty()
	{
		return _a.empty();
	}

	size_t Size()
	{
		return _a.size();
	}

	void Print()
	{
		for (size_t i=0;i<_a.size();++i)
		{
			cout<<_a[i]<<" ";
		}
		cout<<endl;
	}
protected:
	void AdjustDown(size_t root)
	{
		size_t parent=root;
		size_t child=parent*2+1;   //先让child指向左孩子
		while (child<_a.size())
		{
			//保证右孩子不为空
			if (child+1<_a.size() && _a[child+1]>_a[child])
			{
				++child;
			}
			if (_a[parent]<_a[child])
			{
				std::swap(_a[parent],_a[child]);
				parent=child;
				child=parent*2+1;
			}
			else
				break;
		}
	}

	void AdjustUp(size_t child)
	{
		while (child>0)
		{
			size_t parent=(child-1)/2;
			if (_a[parent]<_a[child])
			{
				std::swap(_a[parent],_a[child]);
				child=parent;
			}
			else
				break;
		}
	}
protected:
	vector<T> _a;
};

建小堆，其实思想都类似，所以可以采取一种方式，增强代码的复用性，即定义一个仿函数Less,larger实现数据的比较，从而实现父节点与子节点的交换，进而满足大小堆的特点。

#pragma once

#include<iostream>
#include<assert.h>
#include<vector>
using namespace std;


template<class T>
struct Less
{
	bool operator()(const T& l,const T& r)
	{
		return l<r;
	}
};

template<class T>
struct Larger
{
	bool operator()(const T& l,const T& r)
	{
		return l>r;
	}
};

template<class T,class compare=Larger<T>>
class Heap
{
public:
	Heap(T* a,size_t size)
	{
		assert(a);
		_a.reserve(size);
		for (size_t i=0;i<size;++i)
		{
			_a.push_back(a[i]);
		}

		//建堆，从第一个非叶子节点的父节点开始调整
		for (int i=(size-2)/2;i>=0;--i)   
		{
			AdjustDown(i);
		}
	}

	void Push(const T& d)
	{
		_a.push_back(d);
		AdjustUp(_a.size()-1);
	}

	void Pop()
	{
		assert(!_a.empty());
		std::swap(_a[0],_a[_a.size()-1]);
		_a.pop_back();
		AdjustDown(0);
	}

	const T& Top()
	{
		assert(!_a.empty());
		return _a[0];
	}

	bool Empty()
	{
		return _a.empty();
	}

	size_t Size()
	{
		return _a.size();
	}

	void Print()
	{
		for (size_t i=0;i<_a.size();++i)
		{
			cout<<_a[i]<<" ";
		}
		cout<<endl;
	}
protected:
	void AdjustDown(size_t root)
	{
		compare com;
		size_t parent=root;
		size_t child=parent*2+1;   //先让child指向左孩子
		while (child<_a.size())
		{
			//保证右孩子不为空,比较左右孩子
			if (child+1<_a.size() && com(_a[child+1],_a[child]))
			{
				++child;
			}
			if (com(_a[child],_a[parent]))
			{
				std::swap(_a[parent],_a[child]);
				parent=child;
				child=parent*2+1;
			}
			else
				break;
		}
	}

	void AdjustUp(size_t child)
	{
		while (child>0)
		{
			compare com;
			size_t parent=(child-1)/2;
			if (com(_a[child],_a[parent]))
			{
				std::swap(_a[parent],_a[child]);
				child=parent;
			}
			else
				break;
		}
	}
protected:
	vector<T> _a;
};


测试：

#include"Heap.h"

void Test1()
{
	int a[] = {10,11,13,12,16,18,15,17,14,19};
	Heap<int> hp(a,sizeof(a)/sizeof(a[0]));     //默认大堆
	hp.Print();
	
	cout<<"Empty> "<<hp.Empty()<<endl;
	cout<<"Size> "<<hp.Size()<<endl;
	cout<<"Top> "<<hp.Top()<<endl;

	hp.Push(20);
	hp.Print();
	hp.Pop();
	hp.Print();
}

void Test2()
{
	int a[] = {10,11,13,12,16,18,15,17,14,19};
	Heap<int,Less<int>> hp(a,sizeof(a)/sizeof(a[0]));
	hp.Print();

	cout<<"Empty> "<<hp.Empty()<<endl;
	cout<<"Size> "<<hp.Size()<<endl;
	cout<<"Top> "<<hp.Top()<<endl;

	hp.Push(9);
	hp.Print();
	hp.Pop();
	hp.Print();

}

int main()
{
	//Test1();
	Test2();
	system("pause");
	return 0;
}


下面谈谈堆的建立,Push,Pop时间复杂度问题：

1.在建堆的过程，时间复杂度为O(n*lgn);

2.在Push时，时间复杂度为O(lgn);

3.在Pop时，时间复杂度为O(lgn).

再引入一个优先级队列的问题，队列本来是“先进先出”的，但是在一些特殊情况下排在队中间的需要比对头元素先出去，这就是优先级问题。

以前解决的方法是：1.在优先位置插入元素，时间复杂度为O(n);在队头删除元素，时间复杂度O(1).

                                  2.在队尾插入元素，时间复杂度O(1);先找到优先出队列元素，再Pop,时间复杂度为O(n).

这两种方法，总的来说Push,Pop时间复杂度都为O(n).

学习堆之后，我们解决这个问题就可以更高效了，堆的Push,Pop总的时间复杂度才O(lgn).相比上面的方法，在处理大量数据时这种方法很占优势。

在堆得基本操作实现后，优先级队列可实现为：

template<class T,class compare=Larger<T>>
class PriorityQueue
{
public:
	PriorityQueue(T* a,size_t size)
		:_h(a,size)
	{}
	void Push(const T& d)
	{
		_h.Push(d);
	}
	void Pop()
	{
		_h.Pop();
	}
	bool Empty()
	{
		return _h.Empty()==0;
	}
	size_t Size()
	{
		return _h.Size();
	}
	const T& Front()
	{
		return _h.Top();
	}
	void PrintPriorityQueue()
	{
		_h.Print();
	}
protected:
	Heap<T,compare> _h;
};

测试用例： 

void Test3()
{
	int a[] = {10,11,13,12,16,18,15,17,14,19};
	PriorityQueue<int,Larger<int>> h(a,sizeof(a)/sizeof(a[0]));
	h.PrintPriorityQueue();  //19 17 18 14 16 13 15 12 10 11

	cout<<"Empty> "<<h.Empty()<<endl;
	cout<<"Size> "<<h.Size()<<endl;
	cout<<"Top> "<<h.Front()<<endl;

	h.Push(20);               //20 19 18 14 17 13 15 12 10 11 16
	h.PrintPriorityQueue();
	h.Pop();
	h.PrintPriorityQueue();

	PriorityQueue<int,Less<int>> h1(a,sizeof(a)/sizeof(a[0]));
	h1.PrintPriorityQueue();   //10 11 13 12 16 18 15 17 14 19
	h1.Push(9);               
	h1.PrintPriorityQueue();    //9 10 13 12 11 18 15 17 14 19 16
	h1.Pop();
	h1.PrintPriorityQueue();
}





















用堆实现优先级队列
medouyoulo的博客
07-12 430
堆的数据结构 堆是一颗二叉树 T ，树在它的位置（节点）上存储了集合中的元组并且满足两个附加的属性：关系属性以存储键的形式在T中定义；结构属性以树 T 自身形状的方式定义 关系属性如下： Heap-Order是属性： 在堆 T 中，对于除了根的每个位置 p ，存储在 p 中的键值大于或等于存储在 p 的父亲节点的键值。 作为 Heap-Order 属性的结果，T 中从根到叶子的路径上的键值是以非递减顺序排列的，即一个最小的键总是储存在 T de 根节点中。因此调用 min 或 remove_min 时，能够
优先级队列（Priority Queue）模拟实现
最新发布
qq_62741582的博客
01-10 525
优先级队列模拟实现
一个用堆实现的优先级队列
08-20
一个用堆实现的最大优先级队列，支持模板，动态内存申请，一个小例子，VS2008编译通过，大家一起进步。
堆--优先级队列--topK问题
Meliorem的博客
09-21 637
堆是一个用途很广泛的数据结构，是实现topK问题、堆排序以及优先级队列等问题的必备工具。深刻理解堆这种数据结构，掌握实现堆的技能是学习数据结构非常重要和必备的 一环。         堆的本质是：                     vector + 向上调整 和 向下调整          人们在想象中把它抽象为一棵每个父亲节点都比它两个子节点 大/小 的二叉树   
堆实现的优先级队列
zsy112371的专栏
04-05 420
堆实现的优先级队列的主要方法说明： （1）HEAP_MAXIMUM(int[] a)   返回中具有最大关键字的元素 （2）HEAP_EXTRACT_MAX(int[] a)   去掉并返回具有最大关键字的元素 （3）HEAP_INCREASE_KEY(int a[],int i,int k)    将第i个元素的关键字值增加到k，k不能小于x的原关键字的值 （4）MAX_HEAP_INS
优先级队列详解
m0_62916537的博客
11-18 908
动力节点小编来为大家进行优先级队列详解，优先级队列是一种特殊类型的队列，其中每个元素都与一个优先级值相关联。并且，元素根据其优先级提供服务。即，首先服务更高优先级的元素。 但是，如果出现具有相同优先级的元素，则按照它们在队列中的顺序提供服务。 分配优先级值 通常，在分配优先级时考虑元素本身的值。例如， 具有最高值的元素被认为是最高优先级的元素。但是，在其他情况下，我们可以假设具有最低值的元素作为最高优先级元素。 我们还可以根据需要设置优先级。 优先队列和普通队列的区别 在队列中，执行先进先
6_7.rar_C++_inventedjoc_probablyjzn_基于最小化堆的整型优先级队列
09-24
这种数据结构特别适合用于实现优先级队列，因为它能保证每次删除的都是当前队列中最小的元素。 首先，我们需要理解C++中的堆数据结构。在C++标准库中，`<queue>`和`<priority_queue>`头文件提供了队列和优先级队列...
堆及相关问题
T_tangcのblog
10-08 638
堆的定义 堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。 将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。 堆的本质 vector+向下调整算法/向上调整算法 注意：这棵树是完全二叉树   向下调整...
应用--堆的建立,调整
zisuu的博客
04-13 332
什么是堆 两个特性 结构性：用数组表示的完全二叉树 有序性：任一结点的关键字是其子树所有结点的最大值（或最小值） “最大堆(MaxHeap)”，也称"大顶堆"：最大值 最小堆(MinHeap)”，也称"小顶堆"：最小值 构建最大堆: 建立堆的主要函数 存储结构体: struct node{ int *data; int size; }; 1 create() 初...
优先级队列（头条面试题）
程序猿DD
01-04 1237
来源：算法面试题优先级队列，不同于先进先出队列，其对每一个元素指定了优先级，一般情况下，出队时，优先级越高的元素越先出队。在面试过程中，优先级队列是面试官喜欢问的一个考点...
优先级队列
_
05-05 3236
什么是优先级队列呢？我们得首先清楚优先级的概念。有这样一个例子，在一家医院里面，一开始的时候看病是按照先到先看的顺序，也就是我们前面学到的队列。然后有一天一个身受重伤的病人来了，护士告诉他说你去排队吧，然后还没有等到他排到就不幸去世了。这件事情让医院明白了一个道理，那就是针对不同情况的病人，需要给他们一个不同的级别，例如受重伤的人就应该最先被治疗，而仅仅是轻微感冒这类似的问题则可以稍微延后一点......
优先队列的经典问题
底层码农
10-13 6486
优先队列的经典问题 347. 前 K 个高频元素
用堆实现优先级队列（Priority Queue）
t_wu的博客
04-13 5387
1.优先级队列定义: 优先级队列（priority queue） 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有（1）查找（2）插入一个新元素 （3）删除 一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素 。    对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。2.优先级队列的实现方案    优先级队列的实现既要兼顾成本，也要兼顾效率 ...
优先级队列 top-K 问题 -- java
weixin_45975659的博客
07-10 701
一、概念简介 在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，首先处理优先级高的对象，然后处理次高的对象。 举一个例子：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。 在这种情况下，我们的数据结构应该提供两个基本的操作：一个是返回高优先级对象，一个是添加新的对象。 这种数据结构就是优先级队列(Priority Queue) 。 最常见的实现方式是用堆来实现。 二、常见操作（代码在最后实现） 入队列 步骤（以大堆为例）： a. 首先按尾插方式放入数组 b. 比较其和其父节
优先级队列（最大、最小堆）总结
ha______haha的博客
03-05 2958
优先级队列前言一、优先级队列二、与普通队列的对比三、优先级队列的实现（最大堆）1.最大堆的实现2.优先级队列的实现四、优先级队列的应用1.创建优先级队列2.使用优先级队列五、使用优先级队列解决问题1.[面试题 17.14. 最小K个数](https://leetcode-cn.com/problems/smallest-k-lcci/)2.[1046. 最后一块石头的重量](https://leetcode-cn.com/problems/last-stone-weight/)3.[347. 前 K 个高频
堆的创建以及堆的基本操作
一个计算机爱好者学习历程
12-06 3115
一、堆的基本概念 概念：将元素储存在一维数组中--->形成一颗完全二叉树 条件限制：每个节点比其孩子节点都大（小）--->大（小）堆 大堆： 二、堆的特性 特性：堆顶元素是所有元素中最大（小）的 任意节点都比其孩子节点大（小） 从堆顶到所有叶子路径中是降序（升序） 三、堆的相关操作 1.创建堆 头文件： #pragma once #include<stdio.h> #include&...
完全二叉堆接口实现与优先级队列操作
本文主要介绍了一个完全二叉堆（Complete Binary Heap）的数据结构及其C++实现，这是在优先级队列（Priority Queue）中常用的一种数据结构。完全二叉堆是一种特殊的二叉树，其中每个层次的节点数最多比上一层多一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值