c++ STL二叉堆(优先队列)

最新推荐文章于 2024-05-16 16:03:36 发布
最新推荐文章于 2024-05-16 16:03:36 发布
阅读量1.2k 收藏 6
点赞数 6
文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/okok__TXF/article/details/120722582
版权
本文详细介绍了C++中如何手动实现二叉堆（优先队列），包括插入、删除、调整等操作，并通过示例代码进行演示。接着，讲解了STL中的优先队列`priority_queue`的使用，包括最小堆和最大堆，并展示了自定义比较函数的方法。此外，还提供了自定义类型在优先队列中的应用示例。
摘要由CSDN通过智能技术生成

c++ STL二叉堆(优先队列)

1.介绍

完全二叉树：叶子节点只会出现在最后2层，且最后一层的叶子节点都靠左对齐。

在这里插入图片描述

二叉堆 (优先队列)：一种特殊的完全二叉树，父结点值比子结点大或者小。

最小堆（小根堆）：父结点比子结点都要小

最大堆（大根堆）：父结点比子结点都要大

二叉堆前提是他必须是一颗完全二叉树！！！！！

在这里插入图片描述

既然可以按顺序标号，那么我们就可以用一个数组来把这颗树存起来了

在这里插入图片描述

根节点下标为1，左孩子下标 父结点下标*2 ，右孩子下标 父结点下标*2+1

反过来，我们知道孩子的下标，求父结点的下标 孩子的下标 / 2

如果这是最小堆最小元素就是 数组[1]; 反之，最大堆最大的 数组[1];

2.手写堆（可以跳过直接看3）

样例堆如下图：
在这里插入图片描述

删除元素：(删除1)

让堆顶的结点和最后一个元素交换，再删除最后一个元素，最后对堆进行调整（下沉）；

在这里插入图片描述

void down( int i ) 
{
    int t, flag = 1;//flag来标记符不符合堆的特性
    while ( i * 2 <= n && flag ) {
        t = i*2;//左孩子
        if ( i * 2 + 1 <= n ) { //有右孩子
            if ( h[i*2] > h[i*2+1] ) {
                t = i*2+1;
            }
        }
        if ( h[t] > h[i] ) {
            flag = 0;
        }
        else {
            swap(t, i);//交换下标t,i的数组元素
            i = t;
        }
    }
}
void delete()
{
    swap(1, n); //交换下标为1 和 n的元素
    n--;//堆的size-1
    down(1);   //下沉
}

插入元素

插入元素：插入元素0

先让n++，h[n] = 0, 再对0进行上浮

在这里插入图片描述

void up( int i)//上浮下标为i的元素
{
    if ( i == 1 ) return ;//i=1就是根节点嘛
    
    int flag = 1;
    while ( i != 1 && flag ) {
        if ( h[i] < h[i/2] ) {
            swap(i, i/2);
        }
        else {
            flag = 0;
        }
        i /= 2;  //i要时刻跟踪着我们插入的结点
    }
}
void insert( int x ) 
{
    n++;
    h[n] = x;//h数组表示存结点的数组
    up(n);
}

创建堆:

先用数组存起来所有元素，然后从倒数第二层依次下沉：

void create()
{
    //n为堆中最后一个结点的位置，
	for ( int i = n/2; i >= 1; --i ) {
        down(i);
    }    
}

完整代码

#include <iostream>
//堆的基本常规操作

using namespace std;
int n, h[105];

//交换下标元素
void swap( int i, int j);
//下沉
void down( int i );
void delete1();

//上浮
void up( int i );
void insert( int x );

//创建堆
void create();

//主函数
int main()
{
	cin >> n;
	for ( int i = 1; i <= n; ++i ) {
		cin >> h[i];
	}
	create();
	
	for ( int i = 1; i <= n; ++i ) {
		cout << h[i] << ' ';
	}
	return 0;
}

void swap( int i, int j)
{
	int temp = h[i];
	h[i] = h[j];
	h[j] = temp;
}

void delete1()
{
	swap(1, n);
	n--;
	down(1);
}

void down( int i )
{
	int t, flag = 1;
	while ( i * 2 <= n && flag ) {
		//表示左孩子的下标
		t = i * 2;
		//在判断有没有右孩子
		if ( i * 2 + 1 <= n ) {
			if ( h[i*2+1] < h[i*2] ) {
				t = i*2+1;
			}
		}
		if ( h[t] > h[i] ) {
			flag = 0;
		}
		else {
			swap(i, t);
			i = t;
		}
	}
}
void insert( int x )
{
	n++;
	h[n] = x;
	up(n);
}
void up( int i )
{
	//如果i等于1，直接跳出循环
	if ( i == 1 ) return ;
	
	int flag = 1;
	while ( i != 1 && flag ) {
		if ( h[i] < h[i/2] ) {
			swap(i, i/2);
			i /= 2;
		}
		else {
			flag = 0;
		}
	}
}

void create()
{
	for ( int i = n/2; i >= 1; --i ) {
		down(i);
	}
}

3.STL优先队列

priority_queue<int, vector< int>, greater< int> > q; //最小堆

priority_queue<int, vector< int>, less< int> > c; //最大堆

基本操作：

方法用途
top()访问队头元素，只是访问
empty()队列是否为空
size()返回队列内元素个数
push()插入元素到队尾 (并排序)
pop()弹出队头元素，无返回值
emplace()原地构造一个元素并插入队列
swap()交换内容

定义：priority_queue<类型，容器方式，比较方法> q;

例子：priority_queue<int, vector< int>, greater< int> > q;

容器方式STL里面默认用的是vector；

类型可以自定义；

c++默认是一个最大堆 priority_queue<int, vector< int> > q 等同于 priority_queue< int, vector< int>, less< int> > q

#include <iostream>
#include <queue>
using namespace std;

//定义优先队列a,b,c，事实上三者一毛一样的
priority_queue<int> a;
priority_queue<int, vector<int> > b;//默认vector
priority_queue<int, vector<int>, less<int> > c; //默认less

int main()
{
	for ( int i = 0; i < 5; ++i ) {
		a.push(i);//加入元素
		b.push(i);
		c.push(i);
	}
	
	cout << "A：";
	while ( !a.empty() ) {
		cout << a.top() << ' ';
		a.pop();
	}
	cout << endl;
	
	cout << "B：";
	while ( !b.empty() ) {
		cout << b.top() << ' ';
		b.pop();
	}
	cout << endl;
	
	cout << "C：";
	while ( !c.empty() ) {
		cout << c.top() << ' ';
		c.pop();
	}
	cout << endl;
	
	return 0;
}

来一个类型为pair的，默认是先比较第一个，在比较第二个

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() 
{
    priority_queue<pair<int, int> > a;
    pair<int, int> b(1, 2);
    pair<int, int> c(1, 3);
    pair<int, int> d(2, 5);
    a.push(d);
    a.push(c);
    a.push(b);
    while (!a.empty()) 
    {
        cout << a.top().first << ' ' << a.top().second << '\n';
        a.pop();
    }
}

//如果pair里面的类型是我们自定义的，c++没有给我们准备比较规则，那么我们就要自己写比较规则了

自定义比较方法

看看优先队列定义：

template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;

参数3需要指定一个实现了 operator< 操作符的类（叫做仿函数或者函数对象，实际上就是类，只是调用时写起来像函数一样）

假如我们不想用c++的greater,我们要自己写，自己来做最小堆

#include <iostream>
#include <queue>
using namespace std;

struct cmp{
	//左边是队尾，右边是队首
	//即队首b 小于 其他元素
	//最小堆
	bool operator () ( int a, int b ) {
		return b < a;
	}
};

int main()
{
	priority_queue<int, vector<int>, cmp> c;
	
	for ( int i = 0; i < 5; ++i ) {
		c.push(i);
	}
	
	cout << "C：";
	while ( !c.empty() ) {
		cout << c.top() << ' ';
		c.pop();
	}
	cout << endl;
	
	return 0;
}

自定义类型

less

#include <iostream>
#include <queue>
#include <string>
using namespace std;

//学生，假设年龄小的优先级高
//年龄相同，按姓名字典序
typedef struct Student{
	int age;
	string name;
}Stu;
//b是队首元素
bool operator < (Stu a, Stu b)
{
	if (a.age == b.age) return b.name > a.name;//按字典序来看优先级
	return b.age < a.age;//年龄小的优先级高
}

int main()
{
	priority_queue<Stu, vector<Stu>, less<Stu> > c;  //================>这里是less,就重写小于
	
	for ( int i = 0; i < 5; ++i ) {
		Stu a = {i, "s"};
		c.push(a);
	}
	
	cout << "C：\n";
	while ( !c.empty() ) {
		cout << c.top().name << ' ' << c.top().age << endl;
		c.pop();
	}
	cout << endl << endl;
	
	Stu a = {10, "田小锋"}; c.push(a);
	Stu b = {10, "田小锋01"}; c.push(b);
	cout << "C：\n";
	while ( !c.empty() ) {
		cout << c.top().name << ' ' << c.top().age << endl;
		c.pop();
	}
	cout << endl;
	
	return 0;
}

greater

#include <iostream>
#include <queue>
#include <string>
using namespace std;

//学生，假设年龄小的优先级高
//年龄相同，按姓名字典序
typedef struct Student{
	int age;
	string name;
}Stu;
//b是队首元素
bool operator > (Stu a, Stu b)
{
	if (a.age == b.age) return b.name > a.name;//按字典序来看优先级
	return b.age < a.age;//年龄小的优先级高
}

int main()
{
	priority_queue<Stu, vector<Stu>, greater<Stu> > c; //===============>这里是greater,就重写>
	
	for ( int i = 0; i < 5; ++i ) {
		Stu a = {i, "s"};
		c.push(a);
	}
	
	cout << "C：\n";
	while ( !c.empty() ) {
		cout << c.top().name << ' ' << c.top().age << endl;
		c.pop();
	}
	cout << endl << endl;
	
	Stu a = {10, "田小锋"}; c.push(a);
	Stu b = {10, "田小锋01"}; c.push(b);
	cout << "C：\n";
	while ( !c.empty() ) {
		cout << c.top().name << ' ' << c.top().age << endl;
		c.pop();
	}
	cout << endl;
	
	return 0;
}

下面是直接在结构体里面重写比较方法

#include <iostream>
#include <queue>
#include <string>
using namespace std;

//学生，假设年龄小的优先级高
//年龄相同，按姓名字典序
typedef struct Student{
	int age;
	string name;
	
	//b是队首元素
	bool operator > ( const Student b) const  //这个const不能少哦，
	{
		if (age == b.age) return b.name > name;//按字典序来看优先级
		return b.age < age;//年龄小的优先级高
	}
}Stu;


int main()
{
	priority_queue<Stu, vector<Stu>, greater<Stu> > c;
	
	for ( int i = 0; i < 5; ++i ) {
		Stu a = {i, "s"};
		c.push(a);
	}
	
	cout << "C：\n";
	while ( !c.empty() ) {
		cout << c.top().name << ' ' << c.top().age << endl;
		c.pop();
	}
	cout << endl << endl;
	
	Stu a = {10, "田小锋"}; c.push(a);
	Stu b = {10, "田小锋01"}; c.push(b);
	cout << "C：\n";
	while ( !c.empty() ) {
		cout << c.top().name << ' ' << c.top().age << endl;
		c.pop();
	}
	cout << endl;
	
	return 0;
}
okok__TXF
关注
STL 优先队列学习（二叉堆）
杨鑫newlife的专栏
11-29 2585
大家找到这篇博客说明你对于数据结构或者c++有所了解， 其实这里讲的是数据结构算法中的二叉堆的模板实现，对于二叉堆对来说有大顶堆，小顶堆。 这里的C++中的STL库中可以实现，这一功能简化了自己手写模板的麻烦，增加了运用的方便。 例如一个程序： 就可以实现对于二叉堆挥着队列中的元素进行排序选择最大的元素。  #include #include #include using n
c++优先队列 priority_queue 二叉堆 最大堆实现
chen_wen_jun的博客
11-16 413
文章目录前言一、priority_queue使用方式1.初始化方式2.成员函数二、 二叉堆的实现原理二、自己实现的priority_queue 最大堆代码 前言 c11 stl中提供优先队列的数据结构，可以实现最大堆和最小堆 一、priority_queue使用方式 1.初始化方式 std::prioriry_queue<int> tmp; //默认最大堆 std::priority_queue<int, vector<int>, std::greater<int
C++STL之二叉堆
weixin_34080571的博客
01-15 496
2019独角兽企业重金招聘Python工程师标准>>> ...
STL建立二叉堆
qq_37864983的博客
07-19 417
通过STL建立二叉堆 STL函数库中的优先队列底层就是二叉堆的建立priority_queue<>; 简单的整数的比较直接用默认的比较方法就行了，如果是结构体或者别的类型需要自己手写比较方法。 int类型的数据默认比较方法是大根堆less int main() { int a[]={5,6,5,1,2,3,8,5,9}; priority_queue<int,ve...
C++ STL源码剖析 -- 二叉堆
每天写一点，进步一点点
12-27 557
1 二叉堆 二叉堆，就是一种完全二叉树，即整个二叉树除了最底层的叶子节点之外，是填满的，而最底层的叶子节点中间也没有空隙,如下图所示： 使用数组层级存储 | * | A | B | C | D | E | F | G | H | I | J | 如果0位置保留，从1位置开始保存根节点，那么i位置的某个节点，其左孩子节点必定在2i位置，其右孩子节点则在2i+1位置，其父节点则位于i/2。 如果0位置使用，从0位置开始保存根节点，那么i位置的某个节点，其左孩子节点必定在2i+1位置，其右孩子节点则在2i+2位
数据结构与算法——优先队列类的C++实现(二叉堆)
weixin_34032621的博客
07-31 152
优先队列简单介绍： 操作系统表明上看着是支持多个应用程序同一时候执行。其实是每一个时刻仅仅能有一个进程执行，操作系统会调度不同的进程去执行。每一个进程都仅仅能执行一个固定的时间，当超过了该时间。操作系统就会暂停当前执行的进程，去调度其他进程来执行。 实现这样的进程调度的一种方法是使用队列。開始的时候进程被放在队列的末尾，调度程序将重复提取队列中的第一个进程来执行。直到执行完成或时间片用...
SuanFan.zip_A二叉堆_A星 二叉堆_C++_c++11 a星算法_二叉堆
09-20
A*算法是一种在图中寻找最短路径的搜索算法，而二叉堆则是一种高效的优先队列数据结构，常用于优化路径查找过程。 首先，A*算法的核心在于其引入了启发式信息来指导搜索方向，从而提高效率。它通过结合实际代价（g...
理解数据结构：二叉堆与优先队列
在C++中，STL（Standard Template Library）提供了`<queue>`和`<priority_queue>`容器，其中`priority_queue`就是基于堆实现的，可以方便地实现最大堆或最小堆功能。 堆是一种高效的数据结构，特别适用于需要快速...
C++ STL库源代码(SGI版本)
最新发布
06-04
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了一系列高效、可重用的数据结构和算法。在这个“C++ STL库源代码(SGI版本)”中，我们主要关注的是SGI（Stanford Graphics ...
C++优先队列.pdf
04-12
C++标准模板库（STL）中的优先队列是一种特殊的容器适配器，其实现基于二叉堆。 #### 二、优先队列与普通队列的区别 1. **普通队列**遵循先进先出（FIFO）的原则，即最先加入队列的元素最先被移除。 2. **优先队列*...
C++ STL 堆
大脑白质的博客
06-05 580
#include <queue> #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { //大根堆 //push,pop,top,empty,size priority_queue<i...
C++STL之堆
mijoe10的博客
09-15 673
C++STL恶心到死，不过学会了就比较便捷,前几天学习了一下C++STL的堆操作，现在来口胡一下^_^first at all: STL堆要用到头文件#include<algorithm>,所以，先把头文件打好吧 下面_first和_last为可以随机访问的迭代器（指针），_comp为比较函数（仿函数），相信大家都明白，但还是啰嗦一下凑字数1.建堆 make_heap(_first,_last
建立二叉堆(STL练习)
yoco的博客
01-10 255
二叉堆的建立 算是对STL的一道练习题 思想： 1.建立向量a，输入测试数据 2.基于数组下标，判断当前堆顶是否已满足要求 Code： #include <cstdio> #include <vector> #include <algorithm> #include <functional> using namespace std; // 传入数组a和下标i，i的左右子树都满足最大堆的性质，函数将a整体调整为最大堆 void heap_down(std::
二叉堆的实现及STL的优先队列
slience_646898的博客
08-14 447
数据结构中的堆与内存模型中的堆不同，堆通常被看作一棵完全树，并且堆中子节点的数值总是不大于或不小于父节点的值。 二叉堆是一棵完全二叉树，其分为大根堆和小根堆。通常使用数组来实现二叉堆，其父子节点间存在位置关系为：索引为i的节点的左孩节点为2*i+1，右孩节点为2*i+2，其父节点为(i-1)/2。 二叉堆的实现核心是添加节点（添加到末尾向上调整）和删除节点（末尾元素覆盖向下调整） 添加节点的...
C++ STL自带的堆_stl 堆
2401_85013241的博客
05-16 353
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）如果你需要这些资料，可以戳这里获取 } struct Node { int x,y; bool operator
手撕C++代码，利用二叉堆实现优先队列
weixin_30975227的博客
07-03 282
最近准备面试，疯狂补数据结构和算法。本文手撕C++代码，使用二叉堆实现优先级队列。
C++ STL自带的堆
tankpanv的博客
09-08 6427
一、STL自带堆：priority_queue stack与queue注意事项： 1 stack不允许有遍历行为，stack也不提供迭代器。SGI STL便以deque作为缺省情况下stack底部结构，称之为adapter（配接器） 2 除了deque之外，list也是双向开口的数据结构 3 queue与stack的情况类似，不提供迭代器，也可以以list作为底层容器,默认为deque。 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值