【算法笔记】栈与队列

已于 2022-04-08 22:26:58 修改
阅读量965 收藏
点赞数
分类专栏： 算法 文章标签： 算法 数据结构
于 2022-01-27 19:34:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/computs/article/details/122695084
版权

基础知识

栈

  1. 栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。
  2. 栈的底层实现可以是vector，deque，list ， 主要就是数组和链表的底层实现。
std::stack<int, std::vector<int> > third;  // 使用vector为底层容器的栈

队列

队列是先进先出的数据结构，同样不允许有遍历行为，不提供迭代器，也可以指定list 为起底层实现

std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列

队列也不被归类为容器，而被归类为container adapter（ 容器适配器）。

例题

232. 用栈实现队列

用两个栈，一个输入栈，一个输出栈，入队时压入输入栈，出队时如果输出栈不为空，则弹出输出栈栈顶元素；如果输出栈为空，将输入栈全部压入输出栈，然后弹出输出栈栈顶元素。
如果输入栈输出栈都为空，则队列为空

class MyQueue {
public:
    stack<int> stin;
    stack<int> stout;
    MyQueue() {

    }
    
    void push(int x) {
        stin.push(x);
    }
    
    int pop() {
        int re;
        if(stout.empty()){
            while(!stin.empty()){
                re=stin.top();
                stin.pop();
                stout.push(re);
            }

        }
        re=stout.top();
        stout.pop();
        return re;
    }
    
    int peek() {
        int re;
        if(stout.empty()){
            while(!stin.empty()){
                re=stin.top();
                stin.pop();
                stout.push(re);
            }

        }
        re=stout.top();
        return re;
    }
    
    bool empty() {
        if(stin.empty() && stout.empty()){
            return true;
        }
        return false;
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

225. 用队列实现栈

解1用两个队列，入栈时，只对q1入队。出栈时，将除尾元素的其余元素依次进入另一个队列，此时尾元素在队首，然后将另一个队列的元素依次入队。
返回栈顶元素，直接返回q1的队尾元素即可。

class MyStack {
public:
    queue<int> q1;
    queue<int> q2;
    MyStack() {

    }
    
    void push(int x) {
        q1.push(x);
        

    }
    
    int pop() {
        int size=q1.size();
        for(int i=0;i<size-1;i++){//弹出q1
            q2.push(q1.front());
            q1.pop();
        }
        for(int i=0;i<size-1;i++){
            q1.push(q2.front());
            q2.pop();
        }
        int x=q1.front();
        q1.pop();
        return x;
    }
    
    int top() {
        int x=q1.back();

        return x;
    }
    
    bool empty() {
        if(q1.empty()){
            return true;
        }
        else{
            return false;
        }
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

解2 用一个队列 出栈时将除队尾元素的其他元素重新依次入队，此时队尾元素就是栈顶元素。

class MyStack {
public:
    queue<int> q;
    MyStack() {

    }
    
    void push(int x) {
        q.push(x);
    }
    
    int pop() {
        int size=q.size();
        int x;
        for(int i=0;i<size-1;i++){
            x=q.front();
            q.pop();
            q.push(x);
        }
        x=q.front();//此时队首元素就是栈顶元素
        q.pop();
        return x;
    }
    
    int top() {
        int x=q.back();
        return x;
    }
    
    bool empty() {
        if(q.empty()){
            return true;
        }
        return false;
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

20. 有效的括号

最先出现的括号最后配对，可以用栈来实现
当遇到括号的左边就入栈，遇到括号的右边就出栈，如果栈非空且栈顶元素与该元素配对就继续比较，否则返回false。
如果最后栈的元素为0，说明所有的括号已经完成配对，返回true。

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for(int i=0;i<s.size();i++){
            if(s[i]=='(' || s[i]=='[' || s[i]=='{'){
                st.push(s[i]);
            }
            else{
                if(!st.empty() && s[i]==')' && st.top()=='('){//!st.empty()是避免出现")"这种情况
                    st.pop();

                }
                else if(!st.empty() && s[i]==']' && st.top()=='['){
                    st.pop();
                }
                else if(!st.empty() && s[i]=='}' && st.top()=='{'){
                    st.pop();
                }
                else{
                    return false;
                }

            }
        }
        if(st.size()==0){
            return true;
        }
        return false;
    }
};

1047. 删除字符串中的所有相邻重复项

解1 相邻重复项可以想到栈的特性
如果栈为空或者栈顶元素与当前元素不一样就入栈，否则出栈，最后就是目标字符串的倒序。

class Solution {
public:
    string removeDuplicates(string s) {
        stack<int> q;
        string re;
        for(int i=0;i<s.size();i++){
            if(q.empty()){
                q.push(s[i]);
            }
            else if(!q.empty() && s[i]==q.top()){
                q.pop();
            }
            else {
                q.push(s[i]);
            }
        }
        while(!q.empty()){
            re+=q.top();
            q.pop();
        }
        reverse(re.begin(),re.end());
        return re;
    }
};

解2 字符串本身就是栈，pop_back()相当于出栈，push_back()相当于入栈，back()返回栈顶元素。

class Solution {
public:
    string removeDuplicates(string s) {
        string re;
        for(char a:s){
            if(re.empty() || re.back()!=a){
                re.push_back(a);
            }
            else{
                re.pop_back();
            }
        }
        return re;
    }
};

解3 删除操作自然也要想到双指针
直接在原来字符串上操作，所以节省了空间
如果s[l]==s[l-1],l--,否则l++

class Solution {
public:
    string removeDuplicates(string s) {
        int l=0;
        int r=0;
        for(;r<s.size();r++){
            s[l]=s[r];
            if(l>0 && s[l]==s[l-1]){
                l--;
            }
            else{
                l++;
            }
        }
        s.resize(l);
        return s;
    }
};

150. 逆波兰表达式求值
逆波兰式

分析：逆波兰表达式就是依照栈创建的，所以直接用一个栈解决
如果当前栈为空或者当前字符串不为运算符就压栈（为方便运算这里建一个int的栈，所以需要类型转换，stoi()：sring转int），如果当前字符串是运算符就连续出栈两次，作为右操作数和左操作数，将运算结果在压入栈。最终返回栈顶元素即为最终结果。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(int i=0;i<tokens.size();i++){
            if(st.empty() || (tokens[i]!="+" && tokens[i]!="-" && tokens[i]!="*" && tokens[i]!="/")){//当前字符串为数字
                st.push(stoi(tokens[i]));
                
            }
            else{
                int r=st.top();
                st.pop();
                int l=st.top();
                st.pop();
                int re;
                if(tokens[i]=="+"){
                    re=l+r;
                }
                else if(tokens[i]=="-"){
                    re=l-r;
                }
                 else if(tokens[i]=="*"){
                    re=l*r;
                }
                else{
                    re=l/r;
                }
                
                st.push(re);
            }
           
        }
         return st.top();
    }
};

239. 滑动窗口最大值

本题思路很明确，就是找窗口的最大值，关键是怎么找这个最大值，如果硬解的话会超时，这就得想一个奇妙的方法来维持窗口的最大值，并且窗口移动时最大值是可以更新的。
这里引入单调队列：队列的元素是单调的
本题需要自己实现单调队列，并且需要用deque，因为涉及队首队尾的删除
这个队列应该包含push(int v)：队尾入队，如果v > 队列的队尾元素，队尾元素出队，直到队列为空或者v<=队列的队尾元素，然后v 队尾入队；否则v 直接队尾入队，这样队列里就是单调的了
pop(int v):队首出队，如果窗口要删除的元素v == 队列的队首元素，队首元素出队（避免不在窗口的元素确还在队列中）；否则就什么也不做。这样当窗口移动时就可以实时更新最大值了。
int front(int v)：返回队列的队首元素

  1. 设置窗口的左端和右端，先将第一个窗口里的元素队列
  2. 记录窗口的最大值即队列的队首元素。当窗口移动时，右端点入队，同时判断左端点是否为队首元素，若是就pop。
class Myqueue {//从大到小的单调队列
public:
	deque<int>q;
	void push(int v) {
		while(!q.empty()&&v > q.back()) {
			q.pop_back();
		}
		q.push_back(v);
	}
	void pop() {
		q.pop_front();
	}
	int front() {
		return q.front();
	}
};
class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        Myqueue q;
        vector<int>result;
        int l,r;
        for(l=0,r=0;r<k;r++){//先将第一个窗口放入单调队列
            q.push(nums[r]);
        }
        result.push_back(q.front());//取第一个窗口的最大值
        for(;r<nums.size();r++){
            if(nums[l]==q.front()){//若移除元素是窗口的最大值，就将它移除
                q.pop();
            }
            l++;
            q.push(nums[r]);//压入新的元素
            result.push_back(q.front());//收集窗口的最大值
        }
        return result;
    }
};

347. 前 K 个高频元素

补充：
一般我们说 top K 问题，就可以用大顶堆或小顶堆来实现，
最大的 K 个：小顶堆
最小的 K 个：大顶堆
堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。从小到大排就是小顶堆，从大到小排就是大顶堆。
大顶堆的根结点是最大值，小顶堆的根结点是最小值。
对于大顶堆：当找到最大值后，将二叉树的最后一个元素于根结点互换，重新构造堆，最终根结点就是次大值。
对于本题要找出现频率>=k的元素，采用小顶堆比较方便，因为每次换掉的都是最大的，最终留下来的就是>=k的元素。

  1. 对元素的频率进行统计
  2. 根据元素的频率进行排序，由于要找前k高的元素，所以采用最小堆
  3. 由于当前堆是从小到大排的，所以弹堆时，从后往前存放结果。

写法1 留下的才是想要的

class Solution {
public:
    class myComparison{
        public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs){
        return lhs.second>rhs.second;//小顶堆
        }
    };
    
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int ,int>umap;
        for(int i=0;i<nums.size();i++){
            umap[nums[i]]++;
        }

        priority_queue<pair<int,int>,vector<pair<int,int> >,myComparison >pri_que;
        for(unordered_map<int,int>::iterator it=umap.begin();it!=umap.end();it++){
            pri_que.push(*it);
            if(pri_que.size()>k){
                pri_que.pop();
            }
        }
        vector<int> result(k);
        for(int i=k-1;i>=0;i--){
            result[i]=pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};

写法2 弹出的就是想要的

class MyCompare{
    public:
    bool operator()(pair<int,int>p1,pair<int,int>p2){//大顶堆，弹出k个就是k个最大的
        return p1.second<p2.second;
    }
};
class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int>map;
        priority_queue<pair<int,int>,vector<pair<int,int>>,MyCompare>pq;
        vector<int>result;
        for(int num:nums){
            map[num]++;
        }
        for(pair<const int,int>p:map){
            pq.push(p);
        }
        for(int i=0;i<k;i++){
            pair<int,int>cur=pq.top();
            pq.pop();
            result.push_back(cur.first);
        }
        return result;
        
        

    }
};

总结

  1. 由于栈结构的特殊性，非常适合做对称匹配类的题目。
  2. 要找窗口的最值考虑单调队列。
  3. 一般我们说 top K 问题或者部分排序，就可以用大顶堆或小顶堆来实现，最大的 K 个：小顶堆。最小的 K 个：大顶堆
progressiveFighting
关注
专栏目录
双指针法的例题汇总（C++力扣）
weixin_45479946的博客
11-08 525
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2] 示例 2： 输入：nums = [10,26,30,31,47,60], target = 40 输出：[10,30] 或者 [30,10] 思路：利用数组排好序的特性。x，y分别指向数组的两端。 当nums[x] + nums[y] == target时，有解{num
【数据结构与算法】栈与队列
dadongwudi的博客
08-05 367
栈 一、什么是栈？ 1.后进者先出，先进者后出，这就是典型的“栈”结构。 2.从栈的操作特性来看，是一种“操作受限”的线性表，只允许在端插入和删除数据。 二、为什么需要栈？ 1.栈是一种操作受限的数据结构，其操作特性用数组和链表均可实现。 2.但，任何数据结构都是对特定应用场景的抽象，数组和链表虽然使用起来更加灵活，但却暴露了几乎所有的操作，难免会引发错误操作的风险。 3.所以，当某个数据集合只涉及在某端插入和删除数据，且满足后进者先出，先进者后出的操作特性时，我们应该首选栈这种数据结构。 三、如何实现栈？
栈和队列——算法笔记
文剑木然的专栏
06-02 202
本文首发在我的个人博客：https://jlice.top/p/7d4wx/。欢迎大家前去参观，么么哒~ 链表 链表可以方便地实现以下操作： 从表头添加元素 Node tmp = front; front = new Node(); front.value = item; // item为添加的元素 front.next = tmp; 考虑边界情况，当链表为空添加元素时的情况，需调整...
算法_栈与队列_基础知识与总结
一个努力生活的人的博客
11-25 515
文章目录栈与队列1. c++中的栈和队列c++中的标准库栈队列2. python中的栈和队列的实现栈队列 栈与队列 队列：先进先出 栈：先进后出 1. c++中的栈和队列 c++中的标准库 C++标准库是有多个版本的，要知道我们使用的STL是哪个版本，才能知道对应的栈和队列的实现原理。 那么来介绍一下，三个最为普遍的STL版本： HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。 P.J.Plauger STL
C++ STL之queue容器，list 容器
xinlongkun的博客
11-09 876
入队： 出队 nclude<iostream> #include<queue> using namespace std; #include<string> class person { public: person(string name,int age) { this->m_Name=name; this->m_age=age; } string m_Name; int m_age; }; vo...
C++ queue的以及优先级队列（堆）的介绍和使用
weixin_59215611的博客
03-09 751
C++ queue的以及优先级队列（堆）的介绍和使用
【算法笔记】栈/队列 的应用-（codeup 1918）简单计算器
null
04-17 1382
栈/队列 的应用-（codeup 1918）简单计算器栈栈的常见操作队列队列常见操作【codeup 1918】 简单计算器 栈 栈：后进先出的数据结构。 栈顶指针：始终指向栈的最上方元素的一个标记。使用数组实现栈时，栈顶指针是一个int型变量（数组下标从零开始），记top；使用链表实现栈时，是一个int* 型指针。 栈中没有元素，栈空时令top为-1。 栈的常见操作 清空 clear() 栈顶指针置为-1 void clear(){ TOP=-1; } 获取栈内元素个数 size() top指针始
《算法笔记》pdf版，欢迎下载学习~
10-10
6. **数据结构**：链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、哈希表等，这些数据结构是实现算法的基础。 7. **字符串处理**：KMP算法、Rabin-Karp字符串匹配、Manacher's Algorithm等，这些对于文本分析...
栈和队列onenote笔记pdf
最新发布
10-16
"栈和队列onenote笔记pdf" 栈和队列是数据结构中两种基本的数据存储结构，它们都是线性表的实现方式，但它们之间有着明显的区别。 首先，栈是一种后进先出的数据结构，即最新添加的元素将被最先删除。栈可以想象成...
PKU数据结构与算法笔记——栈和队列
Berkin Chen的博客
11-24 245
栈和队列 栈 限制在一端访问的线性表，先进后出 栈的主要操作 入栈（push） 出栈（pop） 取栈顶元素（top） 判断栈是否为空（isEmpty） 判断栈是否为满（isFull） 栈的ADT template <class T> class Stack { public: void clear(); bool push(const T item); bool pop(T & item); bool isEmpty(); bool isFu
关于C++的std::queue内存不释放的问题的解决方法
u010029439的博客
06-15 4309
https://blog.csdn.net/zhoukai216/article/details/89403363 最近在使用std::queue的时候，遇到一些奇怪的问题。我们使用std::queue来存放一些临时的缓冲数据，然后有一个线程不断地从queue里取数据，写入到文件中，之后会调用pop()函数将数据弹出。但是很奇怪的地在弹出的过程中，程序的内存占用丝毫没有减少。查了一些资料后发现，貌似std::queue底层自己有一套内存管理机制，只有在程序退出或是queue被销毁的时候才会释放这一部分内存
STL之三：deque用法详解
热门推荐
longshengguoji的专栏
01-19 7万+
deque函数： deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。 (1)    构造函数 deque():创建一个空deque deque(int nSize):创建一个deque,元素个
单向链表的创建与遍历（先进先出和先进后出）
wilver的博客
03-12 4270
先进先出：输入任意一串不为零的数，并建立和前一方向不同的单向链表，并按照先进先出的原则依次输出。#include <iostream> #include <cstdio> #include <cstdlib> using namespace std;typedef struct node { int data; struct node *next; }NODE,*LinkList;
c++ list, vector, map, set 区别与用法比较
weixin_30559481的博客
03-09 1151
http://blog.csdn.net/alex_xhl/article/details/37692297 List封装了链表,Vector封装了数组, list和vector得最主要的区别在于vector使用连续内存存储的，他支持[]运算符，而list是以链表形式实现的，不支持[]。 Vector对于随机访问的速度很快，但是对于插入尤其是在头部插入元素速度很慢，在尾部插入速度很快。L...
队列实现先进先出
Confident_ZYL的博客
03-05 3733
4.1.1分析论证：queue (队列）是一个容器的改编，它实现了一个先进先出的数据结构（FIFO） queue 模板类的定义在头文件中。 与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 定义queue 对象的示例代码如下： queue q1; queue q2; queue 的基本操作有...
python实现队列的基本操作，出队、入队，计算队长
qq_45061361的博客
01-11 1万+
队列是数据结构中常用的一种类型，它和排队是情形一样，先进队列中的元素出队时一定是先出来的，定义一端为队首（队列元素出队的一端），另外一端为队尾（队列元素进队的一端）；循环队列就是将队列的两个指针（首尾指针连接起来，可以更加方便进行操作） 顺序队操作: class Queue(object): #初始化一个队列 def __init__(self): self.__list...
python 用list实现队列_python五种队列详解
weixin_39541212的博客
11-26 608
队列的类别threading.Queuemultiprocessing.Queuequeue.Queueasyncio.QueueList方式实现队列是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表。在Python文档中搜索队列（queue）会发现，Python标准库中包含了四种队列，分别是queue.Queue / asyncio.Queue / multiprocessing.Q...
浙大机试与PAT算法笔记精要
在算法笔记中，学生可以找到与算法相关的一系列知识点，这些知识点往往是编程竞赛和机试中最常考察的部分。由于描述中明确指出该笔记是用C/C++编写的，因此可以推断出资源中包含了与这两种语言相关联的算法实现。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值