C++ 模拟实现stack,queue/仿函数

已于 2022-07-18 10:29:37 修改
阅读量952 收藏
点赞数
分类专栏： C++初阶 文章标签： c++
于 2022-05-03 15:44:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61548909/article/details/124543923
版权

 

目录

 1.stack

2.queue

3.优先级队列priority_queue

优先级队列额外的构造函数（通过区间构造）

​4.仿函数

仿函数与函数指针

显式地写greater和less

 1.stack

#pragma once
#include<vector>
#include<list>
#include<deque>

namespace bit//将实现的栈封装到bit中
{
	// 常规实现数据结构的思路
	//template<class T>
	//class stack
	//{
	//public:
	//	// ....
	//private:
	//	T* _a;
	//	size_t _size;
	//	size_t _capacity;
	//};

	// 容器适配器
	//template<class T, class Container = std::vector<T>>
	//template<class T, class Container = std::list<T>>
	template<class T, class Container = std::deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		/*T top()
		{
			return _con.back();
		}*/

        const T& back()
		{
			return _con.back();
		}


		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}

	private:
		Container _con;
	};
}

stl源码中的实现

 测试：使用string类型数据时容易出现溢出或者截断，存入数据300测试

void test_stack()
	{
		//stack<int> s;
		stack<int, vector<int>> s;
		//stack<int, list<int>> s;
		//stack<int, string> s; // ????

		s.push(1);
		s.push(2);
		s.push(3);
		s.push(4);
		s.push(300);

		while (!s.empty())
		{
			cout << s.top() << " ";
			s.pop();
		}
		cout << endl;
	}

300转换为44 ，故stack<int,string>s存在截断数据丢失的风险

2.queue

#pragma once

namespace bit
{
	// list
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}

		/*T front()
		{
			return _con.front();
		}*/

        const T& front()
		{
			return _con.front();
		}

		/*T back()
		{
			return _con.back();
		}*/

        const T& back()
		{
			return _con.back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

注：队列不能使用vector适配，因为vector不支持pop_front()的接口

3.优先级队列priority_queue

#pragma once

namespace bit
{
	template<class T>
    
    //仿函数/函数对象  -- 对象可以像调用函数一样去使用
	struct less
	{
		bool operator()(const T& l, const T& r)//仿函数重载运算符
		{
			return l < r;
		}
	};


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

	template<class T, class Container = vector<T>, class Compare = std::less<T>>
	class priority_queue
	{
	public:
		//typedef typename Container::value_type VT;

		void AdjustUp(size_t child)
		{
			Compare com;//compare是一个仿函数

			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] > _con[child])
				if (com(_con[parent], _con[child]))//使用仿函数比较
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void push(const T& x)
		{
			_con.push_back(x);

			AdjustUp(_con.size() - 1);
		}

		void AdjustDwon(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				//if (child+1 < _con.size() && _con[child] > _con[child+1])
				if (child+1 < _con.size() && com(_con[child], _con[child+1]))//使用仿函数比较
				{
					++child;
				}

				//if (_con[parent] > _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void pop()
		{
            assert(!_con.empty());
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();

			AdjustDwon(0);
		}

		T top()
		{
			return _con[0];
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

对于插入函数接口，使用向上调整使之为堆

	void push(const T& x)
		{
			_con.push_back(x);

			AdjustUp(_con.size() - 1);
		}

 测试

void test_priority_queue()
	{
		/*less<int> LessCom;
		cout << LessCom(1, 2) << endl;

		greater<int> GreaterCom;
		cout << GreaterCom(1, 2) << endl;*/

		//priority_queue<int> pq;
		priority_queue<int, vector<int>, greater<int>> pq;

		pq.push(2);
		pq.push(5);
		pq.push(1);
		pq.push(6);
		pq.push(8);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}

优先级队列额外的构造函数（通过区间构造）

template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last,
			const Compare& comFunc = Compare())
			: _comFunc(comFunc)
		{
			while (first != last)
			{
				_con.push_back(*first);
			}

			//建堆
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				AdjustDown(i);
			}
		}

解决TopK问题：建立大堆 

void test_priotity_queue2()
	{
		int a[] = { 1,4,2,7,8,9 };
		priority_queue<int>pq(a,a+6);
	}

4.仿函数

 

仿函数与函数指针

 

	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y) const
		{
			return x < y;
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y) const
		{
			return x > y;
		}
	};

	// 优先级队列 -- 大堆 <  小堆 >
	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
		priority_queue(const Compare& comFunc = Compare())
			:_comFunc(comFunc)
		{}

		void AdjustUp(int child)
		{
			//Compare comFunc;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] < _con[child])
				if (comFunc(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void push(const T& x)
		{
			_con.push_back(x);

			AdjustUp(_con.size() - 1);
		}

		void AdjustDown(int parent)
		{
			//Compare comFunc;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				//if (child+1 < _con.size() && _con[child] < _con[child+1])
				if (child + 1 < _con.size() && _comFunc(_con[child], _con[child + 1]))
				{
					++child;
				}

				//if (_con[parent] < _con[child])
				if (comFunc(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void pop()
		{
			assert(!_con.empty());
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();

			AdjustDown(0);
		}

		const T& top()
		{
			return _con[0];
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}

	private:
		Compare _comFunc;
		Container _con;
	};

	void test_priority_queue()
	{
		/*less<int> LessCom;
		cout << LessCom(1, 2) << endl;

		greater<int> GreaterCom;
		cout << GreaterCom(1, 2) << endl;*/

		//priority_queue<int> pq; //使用缺省的 大堆 
		//priority_queue<int, vector<int>, greater<int>> pq; //传仿函数 小堆
		priority_queue<int, vector<int>, bool(*)(int, int)>pq; //传函数指针

		pq.push(2);
		pq.push(5);
		pq.push(1);
		pq.push(6);
		pq.push(8);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}

}

调用默认构造函数初始化后，测试样例中传函数指针出现崩溃。传入函数指针时，compare就为函数指针，用函数指针定义了一个缺省的对象

 此处显式地传了一个参数，其类型就没有用less，用的函数指针(内置类型)。用函数指针定义一个缺省的对象就是空指针，空指针此处调用不了东西

 程序运行的思路

 不用默认构造函数初始化，函数指针作为内置类型的成员,我们不初始化时为随机值

使传入函数指针后可成功运行的调整：在构造函数时把函数指针传递过去（函数名即为函数指针）

 

显式地写greater和less

默认情况下使用库里面的greater和less即可，某些情况下需要显式实现greater和less

void test_Functional()
	{
		vector<int>v;
		v.push_back(2);
		v.push_back(1);
		v.push_back(4);
		v.push_back(5);
		v.push_back(3);

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;

        //less
		sort(v.begin(),v.end());//传迭代器区间,默认按升序排序

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

若想实现降序。此处传的是greater的对象

//greater
		sort(v.begin(), v.end(), greater<int>());
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;

对数组进行排序

//指向数组的原生指针本省就是天然的迭代器
		int  a[6] = { 1,2,5,2,5,7 };
		sort(a, a + 6);
		sort(a, a + 6, greater<int>());

若存在自定义类型的数组或者vector里面存储的是自定义类型，则需要写仿函数

    struct Goods
	{
		string _name;
		double _price;
		size_t _saleNum;
		//...

		bool operator<(const Goods& g1, const Goods& g2)const
		{
			return _price < g.price;
		}
	};

		Goods gds[4] = { { "苹果", 2.1, 1000}, { "香蕉", 3.0, 200}, { "橙子", 2.2,300}, { "菠萝", 1.5,50} };
		sort(gds, gds + 4);

若想按价格，可写一个仿函数按价格排序

struct LessPrice
	{
		bool operator<(const Goods& g1, const Goods& g2)const
		{
			return g1._price < g2._price;
		}
	};
	struct GreaterPrice
	{
		bool operator<(const Goods& g1, const Goods& g2)const
		{
			return g1._price > g2._price;
		}
	};

按销量来比较

    struct LessSaleNum
	{
		bool operator<(const Goods& g1, const Goods& g2)const
		{
			return g1._saleNum < g2._saleNum;
		}
	};
	struct GreaterSaleNum
	{
		bool operator<(const Goods& g1, const Goods& g2)const
		{
			return g1._salNum > g2._salNum;
		}
	};

ScarboroughFair#
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ for_each构造函数和析构函数的调用，仿函数，lambda
一首小夜曲
01-06 833
//for_each()调用三次析构函数 　　仿函数(functor)，就是使一个类的使用看上去象一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。 　　有些功能的的代码，会在不同的成员函数中用到，想复用这些代码。 　　　　1）公共的函数，可以，这是一个解决方法，不过函数用到的一些变量，就可能成为公共的全局变量，再说为了复用这么一片代码，就
c++stack_和_queue用法
05-01
c++stack_和_queue用法，就是这两个函数的用法！
C++--stack的模拟实现
qq_46659987的博客
04-10 273
stack的模拟实现1. 用vector模拟实现stack2. 用list模拟实现stack stack是一种容量适配器，专门用在后进先出操作的上下文环境中，插入删除操作只能从容器的一端进行。 stack是作为容器适配器被实现的，对特定类进行封装作为其底层的容器，提供特定的成员函数来访问其元素，进行压入和弹出的操作。 stack的底层容器可以是任何标准或特定的容器类，这些容器类需要支持判空、尾插、尾删、获取尾部元素的操作，标准容器vector、list、deque皆符合这些需求，没有指定时，默认使用deq
C++stack与queue模拟实现
cdzg_zzk的博客
09-11 1342
C++stack与queue模拟实现前言stack栈适配器stack的成员函数queue队列queue类总结 前言 xxxx无论是当初在学校最先学习C语言版的数据结构，还是现在学习STL，发现大家（包括我）都喜欢将stack（栈）和queue（队列）放在一起。可能是FILO和FIFO两种数据存储方式过于相近，更能深入人心，因此两者经常会被放在一起。但是STL我把他们放在一起更是有原因。因为这两种容器在模拟实现的时候，都会使用到“适配器”。这个在后面我再具体说明。 stack栈 xxxx栈的基本知识相信大
C++仿函数
cri5768的博客
04-04 69
所谓仿函数就是和函数调用非常类似的一种调用方式，实际上仿函数只是重载了()运算符， 这种方式在STL容器函数中使用非常普遍，其中又分为函数对象和谓词 class t { public: void operato...
C++ 栈(Stack)的指针实现：构造析构、相关操作及运算符重载
weixin_53369402的博客
11-01 1231
我们先来看一下Stack要实现的操作，再附上相关代码，基本上和上一篇单链表差不多 一、概述： 分为三部分：1.构造析构 2.相关操作 3.运算符重载 template<class T> class Stack { //运算符<<和 >> 的重载 template<class T> friend ostream & operator << (ostream & out,const Stack<T>
【C++初阶：STL —— stack and queue】stack/queue的介绍及使用 | stack/queue/priority_queue的深度剖析及模拟实现 | 适配器模式 | 仿函数
wh128341的博客
05-02 1464
虽然 cplusplus 把 stack 和 queue 归类到了 Containers 下，但是严格来说 stack and queue 不再是容器了，而属于容器适配器 or 容器配接器，适配器做的功能是转换 —— 它不是直接实现的，而是由其它容器封装转换实现的，在下面的模拟实现我们会细谈。 它做为容器适配器，它与容器有一个具大的差别之一就是它没有迭代器，不是说它不能实现迭代器，而是没有必要实现迭代器，因为它如果实现了迭代器，就没法保障 stack “Last In First Out” 和 queue
【C++】stack/queue/list
uytguytgf的博客
12-04 854
【C++】stack/queue/list
C++ deque/queue/stack的底层原理
TABE_的博客
02-08 1839
这里写目录标题deque容器的存储结构deque容器迭代器的底层实现deque容器的底层实现 deque容器的存储结构 和 vector 容器采用连续的线性空间不同，deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域。 为了管理这些连续空间，deque 容器用数组（数组名假设为 map）存储着各个连续空间的首地址。也就是说，map 数组中存储的都是指针，指向那些真正用来存储数据的各个连续空间。 通过建立 map 数组，deque 容器申请的
C++初阶-stack/queue/priority_queue的使用和模拟
~
01-10 870
【C++初阶学习】stack/queue/priority_queue的使用和模拟零、前言一、stack的介绍和使用1、stack的介绍2、stack的使用二、queue的介绍和使用1、queue的介绍2、queue的使用三、priority_queue的介绍和使用1、priority_queue的介绍2、priority_queue的使用四、容器适配器五、deque的简单介绍六、stack的模拟实现七、queue的模拟实现八、priority_queue的模拟实现 零、前言 本章主要讲解学习C++中的.
c++部分头文件的成员函数
02-18
在VS2022上整理，有关array,set,stack,queue,vector,map,set,priority_queue的成员函数及说明
C++中栈与队列的函数
12-22
　头文件include<stack> 　定义栈 　stack<type>q; 　其中type是栈中数据的类型、q是定义的栈的名字； 　比较常用的函数： 　q.push();将元素压入栈中； 　q.pop(); 将栈顶元素删除； 　q.empty();判断栈...
C++泛型编程，学习总结方便回看！
05-15
C++泛型编程，联系代码手稿。容器、模版、STL：string、vector、deque、stack、queue、list、map、set，函数对象：仿函数、谓词、常见库算法：遍历、查找、排序
数据结构实现（C++版）
11-28
2.1.Queue ........... 队列接口 2.2.Stack .............. 栈接口 2.3.Set .................. 集合接口 2.4.Map ............... 映射接口 2.5.Merger .......... 自定义函数接口 2.6.UnionFind ..... 并查集接口 ...
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 895
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
【最新区块链论文录用资讯】CCF A—INFOCOM 2024 共17篇
软件工程小施同学 的专栏
05-28 1469
详情：https://infocom2024.ieee-infocom.org/program/accepted-paper-list-main-conference。BR-DeFedRL：具有快速收敛和通信效率的拜占庭式鲁棒去中心化联邦强化学习。FileDES：一个安全、可扩展、简洁的基于区块链的去中心化加密存储网络。CRACKLE：具有次线性通信复杂性的基于扇区的快速 BFT 共识。通过可逆 GAN 实现高容量的基于区块链的通用隐写术框架。通过树图区块链的半异步去中心化联邦学习框架。
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 848
string类各函数接口。
C语言 指针——指针变量的定义、初始化及解引用
hangweijie的博客
05-29 1225
目录指针内存如何编址？如何对变量进行寻址？用什么类型的变量来存放变量的地址?如何显示变量的地址?​编辑使用未初始化的指针会怎样？NULL是什么？如何访问指针变量指向的存储单元中的数据？指针变量的定义和初始化
分别对stack<int>, queue<int>, priority_queue<int>的实例执行下面的操作: //调用push函数分别将5, 1, 4, 6压入; //调用两次pop函数; //调用push函数分别将2, 3压入; //调用两次pop函数。 //请问对于三类容器适配器，每次调用pop函数时弹出的元素分别是什么? //请编写程序验证自己的判断c++
05-24
对于stack，操作后弹出的元素为6, 4。 对于queue，操作后弹出的元素为5, 1。 对于priority_queue，操作后弹出的元素为6, 5。 以下是验证程序： ```c++ #include #include <stack> #include <queue> using ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值