栈和队列

最新推荐文章于 2024-09-13 17:43:09 发布
最新推荐文章于 2024-09-13 17:43:09 发布
阅读量116 收藏
点赞数
分类专栏： 数据结构 文章标签： c++ leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73410458/article/details/131698699
版权
本文详细介绍了栈、队列和优先级队列的基本概念、接口以及常见的使用场景，如最小栈问题、栈的压入弹出序列判断、用队列实现栈和TopK问题。同时，提供了这些数据结构的模拟实现，包括C++代码示例，展示了如何利用它们解决实际问题。
摘要由CSDN通过智能技术生成

栈和队列

在这里插入图片描述

一.stack的介绍和使用

（1）概念

  • stack是一种后进先出的容器结构，准确来说stack并不是容器，而是一种容器适配器（对特定类封装作为其底层的容器）。

（2）常见接口

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

（3）使用

1.最小栈问题

最小栈
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
思路：使用两个栈，一个正常存放元素，另一个存放最小值，每次入栈时比较更新即可。

class MinStack {
public:
    MinStack() {

    }
    
    void push(int val) {
        if(_minst.empty() || val <= _minst.top())//_minst为空或者val值小于_minst中最小值则入栈
        {
            _minst.push(val);
        }
        _st.push(val);
    }
    
    void pop() {
        if(_minst.top() == _st.top())//若_st出栈的刚好为最小值，则_minst亦出栈
        {
            _minst.pop();
        } 
        _st.pop();
    }
    
    int top() {
        return _st.top();
    }
    
    int getMin() {
        return _minst.top();
    }
    private:
    stack<int> _st;
    stack<int> _minst;
};
2.栈的压入、弹出序列

栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。
思路：用一个栈模拟栈的压入、弹出即可，每次将压入顺序数组的元素入栈，然后若栈顶元素与弹出顺序的数组元素相同，那么直到栈顶与之不同之前，都将栈中元素出栈。

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int> st;
        int pushi = 0, popi = 0;
        while(pushi < pushV.size())//当pushi未到尽头时就将pushi入栈
        {
            st.push(pushV[pushi++]);
            while(!st.empty() && st.top() == popV[popi])//若st栈顶元素与popi处相同则出栈
            {
                popi++;
                st.pop();
            }
        }
        //若此时st为空，则入出栈对应
        return st.empty();
    }
};

（4）stack 的模拟实现

//Container时容器适配器，默认是deque，即双端队列
template <class T, class Container = deque<T>>
	class stack
	{
	private: 
		Container _c;
	};

#pragma once

namespace lyl
{
	template <class T, class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_c.push_back(x);
		}
		void pop()
		{
			_c.pop_back();
		}
		T& top()
		{
			return _c.back();
		}
		const T& top() const
		{
			return _c.back();
		}
		size_t size()
		{
			return _c.size();
		}
		bool empty()
		{
			return _c.empty();
		}
	private: 
		Container _c;
	};
	void test_stack()
	{
		stack<int> st;
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);
		st.push(5);
		cout << st.size() << endl;
		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
		cout << st.empty() << endl;
	}
}

二.queue的介绍和使用

（1）概念

  • 队列是一种后进后出的容器适配器结构，标准容器类deque和list满足其要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque（双端队列）。

（2）常见接口

函数说明接口说明
queue()构造空的队列
empty()判断队列是否为空
size()返回队列中元素的个数
front()返回队头元素
back()返回对尾元素
pop()将队头元素出队

（3）使用

用队列使用栈

用队列实现栈
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
思路：保证有一个栈始终为空，另一个接受元素。若元素入队，则入非空栈中；若出队头元素，则将一个栈中的元素倒到另一个栈，直到只剩一个元素再出栈即可：

class MyStack {
public:
    MyStack() {

    }
    
    void push(int x) {
        if(!_q1.empty())
        {
            _q1.push(x);
        }
        else
        {
            _q2.push(x);
        }
    }
    
    int pop() {
        if(!_q1.empty())
        {
            while(_q1.size() != 1)
            {
                _q2.push(_q1.front());
                _q1.pop();
            }
            int top = _q1.front();
            _q1.pop();
            return top;
        }
        else
        {
            while(_q2.size() != 1)
            {
                _q1.push(_q2.front());
                _q2.pop();
            }
            int top = _q2.front();
            _q2.pop();
            return top;
        }
    }
    
    int top() {
        if(!_q1.empty())
        {
            while(_q1.size() != 1)
            {
                _q2.push(_q1.front());
                _q1.pop();
            }
            int top = _q1.front();
            _q1.pop();
            _q2.push(top);
            return top;
        }
        else
        {
            while(_q2.size() != 1)
            {
                _q1.push(_q2.front());
                _q2.pop();
            }
            int top = _q2.front();
            _q2.pop();
            _q1.push(top);
            return top;
        }
    }
    
    bool empty() {
        return _q1.empty() && _q2.empty();
    }
    private:
    queue<int> _q1;
    queue<int> _q2;
};

（4）queue的模拟实现

	template <class T, class Container = deque<T>>
	class queue
	{
	private:
		Container _c;
	};

#pragma once

namespace lyl
{
	template <class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_c.push_back(x);
		}
		void pop()
		{
			_c.pop_front();
		}
		T& back()
		{
			return _c.back();
		}
		const T& back() const
		{
			return _c.back();
		}
		T& front()
		{
			return _c.front();
		}
		const T& front() const
		{
			return _c.front();
		}
		size_t size()
		{
			return _c.size();
		}
		bool empty()
		{
			return _c.empty();
		}
	private:
		Container _c;
	};
	void test_queue()
	{
		queue<int> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);
		q.push(5);
		cout << q.size() << endl;
		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
		cout << q.empty() << endl;
	}
}

三、priority_queue的介绍和使用

（1）概念

  • 优先队列是一种容器适配器，根据严格的弱排序标准（默认情况），它的第一个元素总是它所包含的元素中最大的。
  • 简单来说，priority_queue类似于数据结构中的堆，其使用与实现也和堆（Heap）并无二异。

（2）常见接口

函数说明接口说明
priority_queue()构造一个空的优先级队列
empty()判断优先级队列是否为空
top()返回优先级队列中最大（最小）元素，即堆顶元素
push()在优先级队列中插入元素
pop()删除优先级队列中最大（最小）元素，即堆顶元素

（3）使用

TopK问题

数组中的第K个最大元素
给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
思路：使用一个k个数降序的优先级队列（小堆），先将数组中前k个元素入堆，然后遍历数组中剩下的元素，若其大于堆顶元素（堆中最大的元素），则将其入堆，这样最终堆顶元素就是数组中的第k和最大元素，整个堆就是数组中最大的k个数。
这样理解：若数组元素比堆顶元素（最大的元素）还要大，那么将其进堆，最终的小堆就是数组中最大的k个元素。

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        if(nums.size() == 1)
        {
            return nums[0];
        }
        //建k个数的小堆
        priority_queue<int, vector<int>, greater<int>> pq;
        //将数组中的前k个数进堆
        for(int i = 0; i < k; i++)
        {
            pq.push(nums[i]);
        }
        //将数组中剩下的数与堆顶元素比较，若大于堆顶，则弹出堆顶元素，并将数组的数入堆
        for(int i = k; i < nums.size(); i++)
        {
            if(pq.top() < nums[i])
            {
                pq.pop();
                pq.push(nums[i]);
            }
        }
        //最后，堆顶元素即为第k个最大的元素
        return pq.top();
    }
};

（4）priority_queue的模拟实现

仿函数的简单介绍

由于优先级队列的默认顺序是升序，而我们如果要让priority_queue的顺序改为降序（大堆），对于C语言就是用一个函数指针，而对于C++则可以使用仿函数。
C++中，通过在一个类中重载括号运算符的方法使用一个函数对象而不是一个普通函数来实现仿函数。
比如：

//构造一个小堆，其中，greater就是仿函数作为参数
priority_queue<int,vector<int>,greater<int>> q(v.begin(), v.end());
代码实现
	template <class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	private:
		Container _con;
	};


#pragma once

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

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


	template <class T, class Container = vector<T>, class Compare = Less<T>>
	class priority_queue
	{
		void AdjustUp(int child)
		{
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					//迭代
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void AdjustDown(int parent)
		{
			size_t child = parent * 2 + 1;
			while (child < size())
			{
				//选出左右孩子中值较大的那个
				//if (child + 1 < size() && _con[child] < _con[child + 1])
				if (child + 1 < 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;
				}
			}
		}
	public:
		priority_queue()
		{}
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push(*first);
				++first;
			}
			//while (first != last)
			//{
			//	_con.push_back(*first);
			//	++first;
			//}
			建堆
			//for (int i = (size() - 1 - 1) / 2; i >= 0; i--)
			//{
			//	AdjustDown(i);
			//}
		}
		void push(const T& x)
		{
			_con.push_back(x);
			AdjustUp(size() - 1);
		}
		void pop()
		{
			swap(_con[0], _con[size() - 1]);
			_con.pop_back();
			AdjustDown(0);
		}
		const T& top() const
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
		Compare com;
	};

	void test_priority_queue()
	{
		priority_queue<int> pq;
		pq.push(1);
		pq.push(2);
		pq.push(3);
		pq.push(4);
		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
		vector<int> v = { 1,3,5,7,9,2,4,6,8,10 };
		priority_queue<int,vector<int>,Greater<int>> q(v.begin(), v.end());
		while (!q.empty())
		{
			cout << q.top() << " ";
			q.pop();
		}
		cout << endl;
	}
}
TheSoundOfWA
关注
专栏目录
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C语言-栈和队列
m0_73605503的博客
07-22 1225
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
【数据结构】栈和队列
小羊的博客
07-12 2513
栈超超超详解
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 1999
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
栈和队列的转化
xiaobai230811的博客
12-17 1201
栈与队列的相互转换栈和队列是两种基本的数据结构，它们在许多算法和程序中都有应用。虽然栈和队列在概念上是完全不同的，但是我们可以使用两个栈来实现一个队列，或者使用两个队列来实现一个栈。这种转换在某些情况下可能非常有用，例如，当我们的编程环境只提供了栈或队列的实现，但我们需要使用另一种数据结构时。在这篇博客中，我们将详细介绍如何使用两个栈来实现一个队列，以及如何使用两个队列来实现一个栈。我们将提供详细的代码示例，并解释每个函数的工作原理。提示：以下是本篇文章正文内容，下面案例可供参考。
JavaScript栈和队列
qq_44741577的博客
01-31 934
栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。**栈的特点是：**先进后出，或者说是后进先出，从栈顶放入元素的操作叫入栈，取出元素叫出栈。栈的受限性体现在只允许在栈顶插入和删除，因此出栈和入栈都是在栈顶。
栈和队列的概念
stormsunshine的博客
04-14 4237
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
栈和队列原理
qq_43697646的博客
01-24 768
栈和队列是STL库里面的两个数据结构。STL有多个版本，知道STL的具体版本才能知道对应的栈和队列的实现原理。 三个常见的STL版本： （1）HP STL HP STL是C++ STL的第一个实现版本，而且开放源代码，其他版本的C++ STL一般是以HP STL为蓝本实现的。 （2）P.J.Plauger STL 由P.J.Plauger参照HP STL实现，被被Visual C++编译器所采用，不是开源的。 （3）SGI STL 由Silicon Graphics Computer Syst
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 698
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
最新发布
qq_74190237的博客
09-13 157
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
【c++23种设计模式概述】
m0_45463480的博客
09-09 790
c++23种设计模式概述。
C语言作用域
天道酬勤
09-07 1023
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值