【C++】stack、queue、priority_queue的模拟实现

目录

一、stack

🌟stack的简单介绍

🌟stack的基本使用

🌟stack的模拟实现

🌟stack模拟实现的完整代码

🌟容器适配器 

二、queue

🌟queue的简单介绍 

🌟queue的基本使用

🌟queue的模拟实现

🌟deque的简单介绍

<1> deque原理介绍

<2>deque的缺陷

<3>为什么选择deque作为stack和queue的底层默认容器？

三、priority_queue

🌟priority_queue的简单介绍

🌟priority_queue的使用

🌟priority_queue的模拟实现

 ✨push(const T& x)

✨pop()

✨top() / size() / empty()

✨区间迭代器priority_queue(InputIterator first, InputIterator last)

🌟仿函数 

我们可以使用仿函数来模拟实现 priority_queue ：

🌟仿函数的使用：

---

一、stack

🌟stack的简单介绍

 1、堆栈是一种容器适配器，专门设计1用于LIFO环境（后进先出），其中元素仅从容器的一端插入和提取；

2、队长被实现为容器适配器，这些类使用特定容器类的封装对象作为其底层容器，提供一组特定的成员函数来访问其元素。元素从特定容器的“背面”推/弹出，这被称为堆栈的顶部。

3、底层容器可以是任何标准容器类模板或一些其他专门设计的容器类。

🌟stack的基本使用

函数说明	接口说明
stack()	构造空的栈
empty()	检测stack是否为空
size()	返回satck中元素的个数
top()	返回栈顶元素的引用
push()	将元素val压入stack中
pop()	将stack中国尾部的元素弹出

void test_stack0()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);

	cout << s1.size() << endl;

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

int main()
{
   test_stack0();
   return 0;
}

🌟stack的模拟实现

基本框架：

namespace xlf
{
	template<class T>
	class stack
	{
	public:
		stack()
		{}

	private:
		std::vector<T> _v;
	};
}

 •  namespace xlf  取一个命名空间，对标识符的名称进行本地化，以避免命名冲突或名字污染；

 •  template<class T>  模板，这里用的是类模板来进行模拟实现；

 •  stack() {}   无参构造；

 •  public、private  访问限定符；

 •  std::vector<T> _v;  成员变量，这里成员变量的类型 vector 和 list 都可以使用，因为stack是在栈顶 出/入 栈，所以可以使用vector、list的一些函数接口来实现。

成员函数的模拟实现：

		stack()
		{}

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

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

		T& top()
		{
			return _v.back();
		}

		const T& top() const
		{
			return _v.back();
		}

		size_t size() const
		{
			return _v.size();
		}

		bool empty() const
		{
			return _v.empty();
		}

 • push 可以使用 vector 的 push_back() 函数接口来实现，stack 的入栈即为 vector 的尾插；

其他成员函数的模拟实现同理。

🌟stack模拟实现的完整代码

namespace xlf
{
	template<class T>
	class stack
	{
	public:
		stack()
		{}

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

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

		T& top()
		{
			return _v.back();
		}

		const T& top() const
		{
			return _v.back();
		}

		size_t size() const
		{
			return _v.size();
		}

		bool empty() const
		{
			return _v.empty();
		}

	private:
		std::vector<T> _v;
	};
}

🌟容器适配器 

 <1> 适配器是一种设计模式（设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结），该种模式是将一个类的接口转换成客户希望的另外一个接口。

<2> STL标准库中 stack 和 queue 的底层结构

      虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：

 此时stack 的模拟实现可以写为：

namespace xlf
{
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		//构造
		stack()
		{}

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

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

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

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

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



	private:
		Container  _con;
	};

}

适配器模式---转换

迭代器模式---封装统一访问方式

•    template<class T, class Container = deque<T>>  使用适配器

•    Container  _con;   适配器成员变量

stack、queue 不提供迭代器，容器适配器是用这些容器转换出来的（适配器通常不提供迭代器），stack后进先出，如果提供迭代器，就达不到原本的性质了。 

二、queue

🌟queue的简单介绍 

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元
素，另一端提取元素。
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供
一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少
支持以下操作:
  • empty：检测队列是否为空
  • size：返回队列中有效元素的个数
  • front：返回队头元素的引用
  • back：返回队尾元素的引用
  • push_back：在队列尾部入队列
  • pop_front：在队列头部出队列
4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器
类，则使用标准容器deque。

🌟queue的基本使用

void test_queue1()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	q.push(5);

	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
}

int mian()
{
  test_queue1();
  return 0;
}
  

🌟queue的模拟实现

 只能用 deque、list 适配，因为queue不支持头删，没有直接支持的，可以用erase，这时就可以支持使用vector，但是效率就很低。

成员函数的模拟实现和stack类似：

namespace xlf
{
	//只能用deque list适配
	//用vector会报错，队尾插入，队头删除，
	//queue不支持头删（先进先出）（没有直接支持，可以用erase）
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		//构造
		queue()
		{}

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

		void pop()
		{
			//这样就可以支持vector了，但是效率就很低了
			//_con.erase(_con.begin());

			_con.pop_front();
		}

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

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

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

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



	private:
		Container  _con;
	};

}

🌟deque的简单介绍

<1> deque原理介绍

 • deque(双端队列)：是一种双开口的“连续”空间的数据结构；

 • 双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)；

 • 与vector比较，头插效率高，不需要搬移元素；

 • 与list比较，空间利用率比较高;

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态二位数组： 

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”，以及随机访问的假象，落在了deque的迭代器身上 ：

<2>deque的缺陷

（1）与vector比较，deque 的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必 vector 高的。

（2）与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。 但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

<3>为什么选择deque作为stack和queue的底层默认容器？

（1） stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性 结构，都可以作为stack的底层容器，比如vector和list都可以；

（2）queue是先进先出的特殊线性数据 结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如 list。

（3）但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

         • stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进 行操作。

         • 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的 元素增长时，deque不仅效率高，而且内存使用率高。

结合了deque的优点，而完美的避开了其缺陷。

三、priority_queue

🌟priority_queue的简单介绍

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素
中最大的。（默认是大堆）
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶
部的元素)。
3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue
提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的
顶部。
4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过
随机访问迭代器访问，并支持以下操作：
      • empty()：检测容器是否为空
      • size()：返回容器中有效元素个数
      • front()：返回容器中第一个元素的引用
      • push_back()：在容器尾部插入元素
      • pop_back()：删除容器尾部元素
5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue
类实例化指定容器类，则使用vector。
6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用
算法函数make_heap、push_heap和pop_heap来自动完成此操作。

🌟priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue就是大堆。

函数声明	接口说明
priority-queueu() priority_queue(first,last)	构造一个空的优先队列
empty()	检测优先级队列是否为空，是返回true,否则返回false
top()	返回优先级队列中最大（最小）元素，即堆栈元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大（最小）元素，即堆顶元素

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

int main()
{
	int a[] = { 1,5,6,8,4,9,7,3,2,0 };
	priority_queue<int> q1(a, a + sizeof(a) / sizeof(int));
	while (!q1.empty())
	{
		cout << q1.top() << " ";
		q1.pop();
	}
	cout << endl;

	return 0;
}

🌟priority_queue的模拟实现

基本框架：

namespace xlf //命名空间
{
	template<class T, class Container = vector<T>>  //类模板
	class priority_queue
	{
	public:

		//成员函数

	private:
		Container _con;//成员变量
	};

}

•  namespace xlf  命名空间，防止命名冲突；

•  template<class T, class Container = vector<T>>  模板，容器适配器；

 ✨push(const T& x)

//用 < 实现大堆
void adjust_up(int child)
{
	int parent = (child - 1) / 2; //计算父节点的位置
	while (child > 0) //循环结束条件：到堆顶结束
	{
		if (_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);//由这个函数进行扩容

	//向上调整
	adjust_up(_con.size() - 1);//排序的区间长度
}

 priority_queue底层是一个堆，在堆后中插入数据，数据就乱了，因此要向上调整堆的数据。

✨pop()

void adjust_down(size_t parent)
{
	size_t child = parent * 2 + 1;//左孩子
	while (child < _con.size())
	{
		//假设法
		//选择左右孩子大的那个
		if (child + 1 < _con.size() && _con[child] < _con[child + 1])
           //判断是否有右孩子              如果右孩子大就选择右孩子
		{
			++child;
		}
		if (_con[parent] < _con[child])//孩节点大就交换
		{
			swap(_con[parent], _con[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆的删除
void pop()
{
	swap(_con[0], _con[_con.size() - 1]);//首尾交换
	_con.pop_back();//删除尾部数据

	adjust_down(0);//向下调整
}

堆的删除要交换首尾的一个数据，接着删除尾部的数据，最后堆顶的数据就要向下调整大小。

✨top() / size() / empty()

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

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

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

直接返回相应的数据。

✨区间迭代器priority_queue(InputIterator first, InputIterator last)

		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}
			//直接建堆
			//向下调整
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
			{
				adjust_down(i);
			}

		}

我们也可以选择向上调整建堆，但是向下直接建堆的时间复杂度更好哦

🌟仿函数 

• 仿函数/函数对象：重载了 operator() 的类，类的对象可以像函数一样使用。 

•  仿函数：根据需求来实现，并没有规定返回值是什么，返回值也是根据需求来返回的，很灵活，只有 operator() 是固定的；

• 特点：参数个数和返回值根据需求确定，不固定，很灵活；

仿函数的使用：

//仿函数/函数对象：重载operator()的类，类的对象可以像函数一样使用
class Func
{
public:
	void operator()(int n)
	{
		while (n--)
		{
			cout << "Func调用" << endl;
		}
		cout << endl;
	}
};

template<class T>
class myless
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y; 
	}
};

int main()
{
	Func f1;
	f1(10);
	f1.operator()(20);

	//仿函数：根据你的需求，只有operator()是固定的，并没有规定返回值是什么，返回值也是根据你的需求来返回的，更灵活；
	//特点：参数个数和返回值根据需求确定，不固定，很灵活。

	myless<int> lessFunc1;
	cout << lessFunc1(1, 2) << endl;
	//lessFunc1.operator()(1,2);

	myless<string> lessFunc2;
	cout << lessFunc2("1.1","2.2") << endl;

	return 0;
}

我们可以使用仿函数来模拟实现 priority_queue ：

//仿函数的使用场景
namespace xlf
{
	template<class T>
	class myless
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	class mygreat
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	//通过外部来改变排序的规则，而不是在内部改变 >  < 的符号来控制 
	template<class T, class Container = vector<T>,class Comapre=myless<int>>
	class priority_queue
	{
	public:
		//强制编译器生成默认构造
		priority_queue() = default;

		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}
			//直接建堆
			//向下调整
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
			{
				adjust_down(i);
			}

		}


		//用 < 实现大堆
		void adjust_up(int child)
		{
			Comapre comfunc;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] < _con[child])
				if (comfunc(_con[parent] , _con[child]))
				//if (Comapre.operator()(_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);//由这个函数进行扩容

			//向上调整
			adjust_up(_con.size() - 1);//排序的区间长度
		}

		void adjust_down(size_t parent)
		{
			Comapre 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()
		{
			swap(_con[0], _con[_con.size() - 1]);//首尾交换
			_con.pop_back();//删除尾部数据

			adjust_down(0);//向下调整
		}

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

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

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

	private:
		Container _con;
	};

}

此时使用了仿函数，就不用在堆的内部改变 大于/小于  的符号，可以直接在外部的函数直接修改。

🌟仿函数的使用：

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d);

private:
	int _year;
	int _month;
	int _day;
};

 ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

 //自己写一个仿函数改变比较大小的方式
 struct PDateLess
 {
	 bool operator()(Date* p1, Date* p2)
	 {
		 return *p1 > *p2;
	 }
 };

void TestPriorityQueue()
{
	//优先级里面放自定义类型
	// 大堆，需要用户在自定义类型中提供<的重载
	//priority_queue<Date> q1;
	//q1.push(Date(2018, 10, 29));
	//q1.push(Date(2018, 10, 28));
	//q1.push(Date(2018, 10, 30));
	//while (!q1.empty())
	//{
	//	cout << q1.top() << " ";
	//	q1.pop();
	//}
	//cout << endl;


	// 大堆，需要用户在自定义类型中提供<的重载
	//存日期类的指针，此时结果很混乱
	//原因：Date*是按地址比较大小，
	// 并不是说先new的地址小，后new的地址大，地址带有随机性
	
	//我们要的并不是按地址比较大小，所以：自己写一个仿函数PDateLess
	//priority_queue<Date*> q1;
	
	//自己写的仿函数(显示传PDateLess)
	xlf::priority_queue<Date*, vector<Date*>, PDateLess> q1;
	q1.push(new Date(2018, 10, 29));
	q1.push(new Date(2018, 10, 28));
	q1.push(new Date(2018, 10, 30));
	while (!q1.empty())
	{
		cout << *q1.top() << " ";
		q1.pop();
	}
	cout << endl;


	 如果要创建小堆，需要用户提供>的重载
	//priority_queue<Date, vector<Date>, greater<Date>> q2;
	//q2.push(Date(2018, 10, 29));
	//q2.push(Date(2018, 10, 28));
	//q2.push(Date(2018, 10, 30));
	//cout << q2.top() << endl;
}

int main()
{
	TestPriorityQueue();
	return 0;
}

如若对你有帮助，记得点赞、收藏、关注哦！

若有误，望各位，在评论区留言或者私信我 指点迷津！！！谢谢^ ^ ~