数据结构与算法leetcode 刷题008 栈和队列的内容

最新推荐文章于 2024-12-26 09:30:24 发布
原创 最新推荐文章于 2024-12-26 09:30:24 发布 · 263 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文解析了LeetCode中的栈与队列经典题目，包括括号匹配验证、逆波兰表达式计算、路径简化、树的遍历及层序遍历等内容，深入探讨了这些数据结构的应用场景与算法实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

今天刷的内容全都是leetcode中栈和队列的使用

leetcode20：判断是否是匹配括号等;

class Solution {
public:
    bool isValid(string s) {
        int size=s.length();
        if(size%2!=0){
            return false;
        }
        stack<char> Stack;//构建一个stack
        int i;
        for(i=0;i<size;i++){
            if(s[i]=='('||s[i]=='{'||s[i]=='['){
                Stack.push(s[i]);
            }
            else{
                if(Stack.empty())
                    return false;
                if((Stack.top()=='('&&s[i]==')')||(Stack.top()=='{'&&s[i]=='}')||(Stack.top()=='['&&s[i]==']'))
                    Stack.pop();
            }
            
        }
        if(Stack.empty()){
            return true;
        }
        else
            return false;    
    }
};

构建一个栈数据结构来存储相应的数据，如果是左括号就入栈，如果是右括号就出栈，直到所有元素都遍历，如果栈不为空则返回false;

leetcode150:波特兰后续表达式计算,学习的内容是atoi()函数的使用；，时间复杂度都是O(n);

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        int size=tokens.size();
        if(size==1){
            return atoi(tokens[0].c_str());
        }
        stack<int> ss;
        int i=0;
        for(i;i<size;i++){
            if(tokens[i] != "+" && tokens[i] != "-" && tokens[i] != "*" && tokens[i] != "/"){
                //首先将字符串转换为C字符串，然后转换为int类型的数据
                ss.push(atoi(tokens[i].c_str()));
            }
            else{
                int m=ss.top();
                ss.pop();
                int n=ss.top();
                ss.pop();
                if(tokens[i]=="+") ss.push(m+n);
                if(tokens[i]=="-") ss.push(n-m);
                if(tokens[i]=="*") ss.push(m*n);
                if(tokens[i]=="/") ss.push(n/m);
            }
        }
        return ss.top();
};

leetcode71:简化一个字符串linux文件路径的字符串：

class Solution {
public:
    string simplifyPath(string path) {
        //简化路径名称 使用一个栈来维护字符串
        int size=path.size();
        int i=0;
        
        if(path=="") return "";
        stack<string> stacks;
        //首先遍历所有的字符串中的字符
        for(i=0;i<size;){
            while(i<size&&path[i]=='/'){
                i++;
            }
            string s="";
            while(i<size&&path[i]!='/'){
                s+=path[i++];
            }
            if(s==".."&&!stacks.empty()){
                stacks.pop();// 如果是..弹出相应的元素
            }
            else{
                if(s!=".."&&s!="."&&s!=""){
                    stacks.push(s);
                }
            }
        }
        if(stacks.empty()){
            return "/";//如果当前的栈为空 返回当前路径
        }
        string ans="";
        while(!stacks.empty())
        {
            ans="/"+stacks.top()+ans;
            stacks.pop();
        }
        return ans;
        
    }
};

算法的和时间复杂度为O(n);

栈和递归的紧密联系：与二叉树的使用；

leetcode144; 先序遍历算法的使用

1：递归算法的简单实现：

class Solution {
public:
    vector<int> ans;//增加一个类变量来维护相应的数据
public:
        if(root){
            ans.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return ans;
    }
};

居然能通过 运算时间是4ms

2.自己模拟一个栈了维护相应的数据；

struct command{
    string flag;
    TreeNode* node;
    command(string ss,TreeNode *Node):flag(ss),node(Node){}
};//主机构建一个结构体来存储相应的Node节点还有一个flag标志
class Solution {
public:
    vector<int> ans;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        
    //使用栈来模拟递归算法的使用；
    if(root==NULL){
        return ans;
    }
    stack<command> result;
    result.push(command("go",root));//首先将根节点入栈中
    while(!result.empty()){
        command top=result.top();
        result.pop();
        if(top.flag=="out"){
            ans.push_back((top.node)->val);
        }
        else{//对于每一次节点都要进行相应的入栈
            if(top.node->right!=NULL){
                result.push(command("go",top.node->right));
            }
            if(top.node->left!=NULL){
                result.push(command("go",top.node->left));
            }
            result.push(command("out",top.node));
        }
    }
     return ans;   
    }
};

以上的运行时间为3ms

3：采用书本中的构建栈的方式较为复杂：

 vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        TreeNode *p=root;
        if(root==NULL){
            return ans;
        }
        stack<TreeNode *> ss;
        while(p!=NULL||!ss.empty()){
            while(p!=NULL){
                ans.push_back(p->val);
                ss.push(p);
                p=p->left;
                
            }//首先遍历左行节点到最根部，然后再push进右节点;
            if(!ss.empty()){
                TreeNode *q=ss.top();
                ss.pop();
                p=q->right;
            }
        }
        return ans;
}

同理相应的中序遍历的方式也是一样的：

leetcode94:
递归实现：

class Solution {//中序遍历算法
public:
    vector<int> ans;//同样设置一个类属性来存储相应的返回值
    vector<int> inorderTraversal(TreeNode* root) {
        if(root){
            inorderTraversal(root->left);
            ans.push_back(root->val);
            inorderTraversal(root->right);
        }
        return ans;
    }
};

2.模拟栈来实现递归

struct command{
    string val;
    TreeNode *Node;
    command(string val,TreeNode *node):val(val),Node(node){}
};
class Solution {//中序遍历算法
public:
    vector<int> ans;
    vector<int> inorderTraversal(TreeNode* root) {
//         //递归调用 但是返回值的问题需要解决  返回的是vector<int> 类型的数据
//         /*
//         vector<int> ans;
//         if(root==NULL){
//             return ans.push_back(NULL);
//         }
//         else{
//             ans.push_back(root->val);
//             ans.push_back(inorderTraversal(root->left));
//             ans.push_back(inorderTranvesal(root->right));
//         }
//         */
//         vector<int> ans;
//         TreeNode *p=root;
//         if(p==NULL){
//             return ans;// 
//         }
//         stack<TreeNode *> stackss;
//         while(p!=NULL||!stackss.empty()){
//             while(p!=NULL){
//                 stackss.push(p);
//                 p=p->left;//首先找到最左边的子节点;
//             }
//             if(!stackss.empty()){
//             TreeNode *q=stackss.top();
//             ans.push_back(q->val);
//             stackss.pop();
//             p=q->right;
//             }
            
//         }
//         return ans;
        // if(root){
        //     inorderTraversal(root->left);
        //     ans.push_back(root->val);
        //     inorderTraversal(root->right);
        // }
        // return ans;
        if(root==NULL){
            return ans;
        }
        stack<command> ss;
        ss.push(command("go",root));
        while(!ss.empty()){
            command top=ss.top();
            ss.pop();
            if(top.val=="cout"){
                ans.push_back(top.Node->val);
            }
            else{
                if(top.Node->right!=NULL){
                ss.push(command("go",top.Node->right));}
                ss.push(command("cout",top.Node));
                if(top.Node->left!=NULL){
                    ss.push(command("go",top.Node->left));}
            }
        }
        return ans;
    }
};


同理后续遍历采用新的方式也是可以实现：这里不再做详细的介绍了；


队列的内容;

主要是关于树的层序遍历和无权图的最短路径；

leetcode102：
关于树的层序遍历方式；

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //使用队列的数据结构来存储相应的结点，每当有节点pop出去就向队尾中添加结点
        //C++中队列的数据结构是Queue
        vector<vector<int>> ans;
        if(root==NULL){
            return ans;
        }
        queue<TreeNode *> result;//首先将相应的root元素入队
        result.push(root);
        while(!result.empty()){
          //构建一个行的队列，用来存储相应的队列中临时数据
            vector<int> tempVector;
            queue<TreeNode *> tempQueue;
            while(!result.empty()){
                TreeNode *front=result.front();
                result.pop();
                tempVector.push_back(front->val);
                if(front->left!=NULL){
                    tempQueue.push(front->left);
                }
                if(front->right!=NULL){
                    tempQueue.push(front->right);
                }
            }
            ans.push_back(tempVector);
            result=tempQueue;
        }
        return ans;
    }
};

leetcode103：层序遍历树，当时树的遍历方式是zip zap的方式Z的方式来遍历树

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        //方法相同还是使用队列的数据结构来进行存储相应的数据;
        //设置一个flag来表示技术如何加入队列中
        queue<TreeNode *> result;
        vector<vector<int>> ans;
        if(root==NULL){
            return ans;
        }
        int flag=1;
        result.push(root);
        while(!result.empty()){
            queue<TreeNode*> temp;
            vector<int> tempVector;
            while(!result.empty()){
                TreeNode *top=result.front();
                result.pop();
                tempVector.push_back(top->val);  
                if(top->left!=NULL){
                    temp.push(top->left);
                    }
                if(top->right!=NULL){
                    temp.push(top->right);
                    }
                }
            
            if(flag==1){
                ans.push_back(tempVector);
                flag=0;}
            else{
                reverse(tempVector.begin(),tempVector.end());
                ans.push_back(tempVector);
                flag=1;}
            result=temp;}
    
           
        return ans;
    }
};


2020-9-27 //严蔚敏《数据结构》 //二叉链表： 递归、非递归（非递归用栈）先序、中序、后序遍历（非递归后序遍历麻烦点，需要用到flag标志）
weixin_45888287的博客
09-27 396
//严蔚敏《数据结构》 //二叉链表： 递归、非递归（非递归用栈）先序、中序、后序遍历（非递归后序遍历麻烦点，需要用到flag标志） //以及层序遍历（层序用队列） //自学中，加油！！！ //过程很痛，但结果很美 #include<iostream> using namespace std; #define TElemType double typedef struct BiTNode { TElemType data; struct BiTNode* lchild,* rc
数据结构 作业答案 第3章 栈和队列
HKD_WCY的博客
04-06 9261
** 第3章 栈和队列 ** 1．选择题 （1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（ ）种情况。 A．5，4，3，2，1 B．2，1，5，4，3 C．4，3，1，2，5 D．2，3，5，4，1 答案：C 答案解析：栈是后进先出的线性表，不难发现C选项中元素1比元素2先出栈，违背了栈的后进先出原则，所以不可能出现C选项所示的情况。 （2）若已知一个栈的入栈序...
[LeetCode]栈和队列数据结构的相互实现
aixian8156的博客
12-31 247
栈是先进后出，队列是先进后出，这里讨论一下两种数据结构之间的相互实现。 一.用两个栈实现队列 我们用一个栈来实现队列的进队操作（栈A），用另一个栈来实现队列的出队操作（栈B）。 1.入队列： 把元素放进栈A即可。假如栈A已满并且栈B为空，可以先把栈A中的所有元素先弹出并放入栈B中；假如栈B不为空，则出错了（不能插入）。 2.出队列： 假如栈B不为空，直接弹出。假如栈B为...
【数据结构与算法（七）】——栈和队列
OldBowl
05-15 406
这是第七天，每天的开始都问自己昨天做了什么，今天要做什么的一种心情 栈和队列 1、栈（数据结构）：FILO，后进先出 2、队列：LILO，先进先出 这里顺便复习以下《汇编语言（王爽）》中的函数调用栈 函数调用栈 1、几个常用的寄存器： ①ESP：栈指针寄存器，其内存中存放的是一个指针，永远指向系统栈最上面的一个栈帧的顶部。push和pop指令会改变esp的值 ②EB...
2020-11-16 //先序、中序、后序（递归、非递归(栈实现)） 后序非递归用到标志变量flag 以及层序遍历（队列实现）
weixin_45888287的博客
11-16 175
//先序、中序、后序（递归、非递归(栈实现)） 后序非递归用到标志变量flag 以及层序遍历（队列实现） #include<iostream> #include<queue> #include<stack> using namespace std; #define TElemType double typedef struct BiTNode { TElemType data; bool flag;//flag用于非递归后序遍历 struct Bi
【初阶数据结构和算法】leetcode刷题之设计循环队列
hdxbufcbjuhg的博客
11-25 5068
现在我们知道了使用数组，所以循环队列中肯定要有一个数组，但是我们不知道数组的具体大小，需要到时候根据初始化函数的参数确定，所以我们这里直接用一个指针代替，到时候动态申请空间由于队列要遵循头删尾入，所以我们最好像定义队列一样，定义两个下标front和rear分别指向循环队列的头和尾(这个尾相当于顺序表中的size)，方便进行操作，还有就是我们要知道申请了多大空间，所以用一个整型变量capacity来存储那么是否要头删使用数组的效率会很低呢？int* arr;int rear;int front。
【初阶数据结构与算法】栈和队列leetcode刷题之用栈实现队列，用队列实现栈
hdxbufcbjuhg的博客
11-23 2103
在本节的题目中都会用到数据结构栈和队列，由于我们目前没有介绍C++，以C语言的形式来做，所以我们需要把我们之前实现好的栈和队列复制进去再做，等以后我们讲到C++部分就可以使用STL，不用自己手动写栈和队列了。
【初阶数据结构和算法】Leetcode 刷题之设计循环队列
小蜗牛的珍贵百宝箱
12-26 641
循环队列是一种基于数组实现的队列，它通过首尾指针来实现队列的循环结构，从而避免了队列中前端元素的空闲空间浪费。在实际应用中，循环队列可以解决传统队列（如线性队列）在达到数组容量时无法继续插入元素的问题，特别适用于要求队列操作具有固定大小且需要循环的场景。本篇文章将介绍如何设计一个循环队列，并通过 Leetcode 刷题的方式来实现这个数据结构。我们将实现一个类，并通过 Leetcode 题目进行演示。
leetcode刷题之栈与队列
qq_43651945的博客
05-14 382
例题1有效的括号 20. 有效的括号 - 力扣（LeetCode） 给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 此题是栈的经典应用，遇到左括号压栈，遇到右括号则弹出栈并与之匹配，如果不匹配直接返回false 最后判断栈是否为空，栈不为空也返回false public boolean isValid(String s) { Stack<Chara
算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip
10-03
这份压缩包文件“算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip”包含了一系列关于算法、数据结构、LeetCode刷题以及Go和Java语言在解决面试问题中的应用。以下是这些主题的详细讨论...
LeetCode 刷题代码存放与数据结构算法学习历程记录
08-02
通过LeetCode刷题，学习者可以加深对各种数据结构如数组、链表、栈、队列、树、图的理解和应用。同时，算法的训练也有助于学习者掌握各种算法思想，包括但不限于分治算法、动态规划、贪心算法、回溯算法、搜索算法等...
数据结构与算法基础实现、笔记、LeetCode 刷题记录及书籍整理
07-31
例如，数组、链表、栈、队列、树、图等基础数据结构，以及排序、搜索等基础算法都有详尽的实现和解释。同时，资源还包含作者在学习过程中所做的笔记，这些笔记往往包含了对复杂概念的深入解析和个人的理解，是学习...
Java 算法与数据结构：LeetCode 刷题及大厂面试题笔记指南
07-31
2. 数据结构深入：包括了树、图、栈、队列、哈希表等数据结构的特性以及它们在算法中的应用。 3. 中级算法题目：涉及到动态规划、回溯算法、分治算法等中级算法的应用和解题思路。 4. 高级算法与数据结构：包含了...
数据结构与算法的刷题leetcode和学习.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
嵌入式C语言从入门到精通视频教程.zip
08-21
目录： 1.1C语言会被淘汰吗?.mp4 1.2 如何成为嵌入式高手.mp4 1.3 搭建开发环境.mp4 1.4初识程序结构.mp4 1.5单片机程序的编译与运行简介.mp4 2.1 单片机中数据表现形式.mp4 2.2 为什么要引入数据类型.mp4 2.3 为什么要使用C99的整数类型.mp4 2.4 sizeof用法.mp4 2.5 GPIO输出速度影响什么.mp4 2.5 负数的二进制表现形式.mp4 2.6 变量的用法与注意事项.mp4 2.7 浮点型数据类型 2.8 一个字符引入的BUG 2.9 浮点数应用注意事项 2.10 为什么要引入ASCII码 3.1 C语言有哪些运算符 3.2 算数运算符及应用案例 3.3 算数复合赋值运算符 3.4 增1和减1运算符及应用案例 3.5 单片机是如何控制外设的 3.6 牢记位运算符的口诀 3.7 逻辑移位与算数移位的区别 3.8 左移右移位运算应用案例 3.9 位运算应用案例1.mp4 3.10 位运算应用案例2 .mp4 4.1 printf的基本用法.mp4 4.2 printf的精细格式控制.mp4 4.3 printf输出转义序列.mp4 5.1数据运算的类型转换.mp4 5.2数据截断和数据扩充的规则.mp4 5.3数据扩充的应用案例和总结.mp4 5.4数据运算发生溢出的危害.mp4 5.5 数据扩充案例.mp4 5.6 24000000U中的U是做什么用的?.mp4 6.1 bool数据类型.mp4 ............ 网盘文件永久链接
该课题为基于Matlab的人脸考勤系统。如果需要硬件结合的话，可以调取摄像头。带有人机交互界面。可以在人机交互界面的基础之上，进行相应的拓展。人脸库可以使用您自己的真实人脸库。(11).zip
08-21
该课题为基于Matlab的人脸考勤系统。如果需要硬件结合的话，可以调取摄像头。带有人机交互界面。可以在人机交互界面的基础之上，进行相应的拓展。人脸库可以使用您自己的真实人脸库。(11).zip
该课题为基于Matlab的运动目标跟踪系统。可以实时框定运动目标。对运动目标的行为做识别。带有人机交互界面，需要在人机交互界面的基础上进行拓展(12).zip
08-21
该课题为基于Matlab的运动目标跟踪系统。可以实时框定运动目标。对运动目标的行为做识别。带有人机交互界面，需要在人机交互界面的基础上进行拓展(12).zip
毫米波MIMO系统中基于凹度近似的功率分配.zip
08-21
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
该课题为基于Matlab的运动目标跟踪系统。可以实时框定运动目标。对运动目标的行为做识别。带有人机交互界面，需要在人机交互界面的基础上进行拓展(21).zip
最新发布
08-21
该课题为基于Matlab的运动目标跟踪系统。可以实时框定运动目标。对运动目标的行为做识别。带有人机交互界面，需要在人机交互界面的基础上进行拓展(21).zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值