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

已于 2022-07-18 10:29:37 修改
阅读量1k 收藏
点赞数
分类专栏： 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#
关注
专栏目录
C++ for_each构造函数和析构函数的调用，仿函数，lambda
一首小夜曲
01-06 861
//for_each()调用三次析构函数 　　仿函数(functor)，就是使一个类的使用看上去象一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。 　　有些功能的的代码，会在不同的成员函数中用到，想复用这些代码。 　　　　1）公共的函数，可以，这是一个解决方法，不过函数用到的一些变量，就可能成为公共的全局变量，再说为了复用这么一片代码，就
初识C++之模拟实现stack、queue和反向迭代器
Masquerena114514的博客
03-12 614
讲解了stl库中的stack和queue的模拟实现、适配器模式、双端队列及反向迭代器的实现和仿函数的概念
C++--stack的模拟实现
qq_46659987的博客
04-10 346
stack的模拟实现1. 用vector模拟实现stack2. 用list模拟实现stack stack是一种容量适配器，专门用在后进先出操作的上下文环境中，插入删除操作只能从容器的一端进行。 stack是作为容器适配器被实现的，对特定类进行封装作为其底层的容器，提供特定的成员函数来访问其元素，进行压入和弹出的操作。 stack的底层容器可以是任何标准或特定的容器类，这些容器类需要支持判空、尾插、尾删、获取尾部元素的操作，标准容器vector、list、deque皆符合这些需求，没有指定时，默认使用deq
C++stack与queue模拟实现
cdzg_zzk的博客
09-11 1516
C++stack与queue模拟实现前言stack栈适配器stack的成员函数queue队列queue类总结 前言 xxxx无论是当初在学校最先学习C语言版的数据结构，还是现在学习STL，发现大家（包括我）都喜欢将stack（栈）和queue（队列）放在一起。可能是FILO和FIFO两种数据存储方式过于相近，更能深入人心，因此两者经常会被放在一起。但是STL我把他们放在一起更是有原因。因为这两种容器在模拟实现的时候，都会使用到“适配器”。这个在后面我再具体说明。 stack栈 xxxx栈的基本知识相信大
C++仿函数
cri5768的博客
04-04 93
所谓仿函数就是和函数调用非常类似的一种调用方式，实际上仿函数只是重载了()运算符， 这种方式在STL容器函数中使用非常普遍，其中又分为函数对象和谓词 class t { public: void operato...
【C++】stack
weixin_74078718的博客
04-07 7495
stack 的模拟实现，deque的介绍等内容。
c++ vector、stack、queue、map用法总结
yimixgg的博客
04-10 2500
c++ vector、stack、queue、map用法总结 一：vector容器用法总结 参考链接: https://blog.csdn.net/qq_36734094/article/details/79748612#commentBox 在c++中，vector是一个十分有用的容器。 作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能...
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
C++———STL容器个人理解（vector、queue、stack）
最新发布
m0_74939592的博客
11-05 311
在数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。可以定义一个结构体存储入队列，队列的元素可以是单个数据元素，也可以是一个结构体。
c++中stack、queue和vector的基本操作示例
08-29
在C++编程语言中，`stack`、`queue`和`vector`是三种常见的容器，它们各自有不同的特性和用途。接下来我们将深入探讨这些容器的基本操作和示例。 首先，我们来看`stack`（栈），它遵循后进先出（LIFO）原则。栈的...
在使用模板函数来打印map容器时遇到的问题。无法识别迭代器 iterator；
qq_46084757的博客
05-20 262
在使用模板函数来打印map容器时遇到的问题。无法识别迭代器 iterator； 使用C++模板和迭代器时遇到问题 error C2760: 语法错误: 意外的令牌“标识符”，预期的令牌为“;” 原来的错误代码 template<typename T1,typename T2> void printMap(map<T1, T2>& m) { for(map<T1, T2>::iterator it = m.begin();it != m.end();it++)
C++---stack,queue,priority_queue 模拟实现
blue_jun_的博客
10-07 726
deque容器简介，栈和队列及优先级队列实现，仿函数使用
priority_queue(优先级队列)模拟实现(堆方式)
m0_73904148的博客
05-31 890
priority_queue的性质是：每个数据都会携带一个优先级优先级较高的数据会优先出队列这里的优先级可以是数据的大小或者其他，总之这个优先级一定要是可以比较大小的东西这里的优先级队列的实现方式我们采用堆的方式！在我们完成了堆的插入和删除后，基本上其他接口与stack和queue一样直接调用底层容器的接口在栈和队列中，我们讲过适配器的概念，而堆其实也可以理解为一个适配器栈和队列而优先级队列的底层是一个堆来实现的，那么优先级队列也可以理解为适配器。
数据结构与算法——常见排序算法写成模板，新建命名空间打包带走
jay_zzs的博客
09-03 404
1. 前文汇总 前面陆陆续续总结过常用排序算法，如下： 数据结构与算法——快排序 数据结构与算法——插入排序 C++——归并排序，从固定数据类型到函数模板以及使用函数对象自定义递增/递减 数据结构与算法——插入排序——使用C++实现函数模板、 数据结构与算法——希尔排序 数据结构与算法——选择排序 2. 常用排序算法整理 将常用的排序算法进行了实现，写成了模板，并放在了一个命名空间下面。包括插入排序，选择排序，希尔排序，快排序，堆排序和归并排序。 需要注意的就是模板的特化，不能将模板函数
[模板] 树堆 - Treap的指针和数组实现及一些例题
LucienShui
08-19 681
指针版：template <class T, class Compare = std::less<T> > class Treap { private: struct treap {//成员结构体 int size, fix;//以当前节点为根的树的节点数目，和调整树结构的fix随机数 T key;//每个节点的权，可以定义成自己想要的类型 C
C++ STL - stack queue priority_queue 适配器
TPON的博客
10-12 576
C++STL - stack queue priority_queue 容器适配器
【C++学习】【STL】关联式容器【map】【set】
m0_74183164的博客
03-11 475
equal_range(key) 成员方法可以看做是 lower_bound(key) 和 upper_bound(key) 的结合体，该方法会返回一个 pair 对象，其中的 2 个元素都是迭代器类型，其中 pair.first 实际上就是 lower_bound(key) 的返回值，而 pair.second 则等同于 upper_bound(key) 的返回值。也就是说，该方法将返回一个范围，该范围中包含的键为 key 的键值对（map 容器键值对唯一，因此该范围最多包含一个键值对）。
AVL树C++实现
Code & Data & Finance
11-20 1413
用C++实现的AVL树代码和解释 #ifndef __AVL_TREE_H__ #define __AVL_TREE_H__ #include "stdafx.h" stdafx.h里面有#include #include 下面是节点 template struct AVLTreeNode { T key; int height; AVLTreeNode* left; AV
数据结构与算法——插入排序——使用C++实现函数模板
jay_zzs的博客
07-31 1056
1. 插入排序原理 插入排序是最基本的排序算法，之前写过一篇文章实现插入排序，不过是用的C语言+函数指针，使得用户可以自定义升序排序还是降序排序。 现在考虑使用C++，将该算法做成一个函数模板。 2. 将排序算法做成函数模板 几个关键字：【函数模板】，【函数对象】，【匿名函数】，【友元函数】。 对于基本数据类型，构建函数模板比较简单，排序的比较也可以直接用STL里面的less和great函数对象。对于自定义类型的数据，需要实现自定义类型对象的比较，可以1）重载比较运算符，less重载"<"运
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值