浙大数据结构ch2：链表，队列，堆栈

已于 2023-03-28 17:17:17 修改
阅读量381 收藏
点赞数
分类专栏： 学习笔记 数据结构与算法总结 文章标签： 数据结构
于 2022-08-31 17:22:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52812620/article/details/126628217
版权
这篇博客探讨了数据结构中的栈和队列在不同场景下的应用，如模拟队列和堆栈，以及如何使用它们解决实际问题。文章通过C++代码展示了如何用栈实现中缀表达式的后缀转换，同时讲解了广义表的概念，包括其存储结构和操作。此外，还介绍了顺序和链式结构的栈和队列的实现，并提供了相关操作的示例代码。
摘要由CSDN通过智能技术生成

1051 Pop Sequence

#include <bits/stdc++.h>
using namespace std;
stack<int> s;
int n,m,k;
int tmp;
int main(){
    scanf("%d%d%d",&m,&n,&k);
    for (int i=0;i<k;i++){
        stack<int> s;
        int cnt=1;
        bool flag=false;
        for (int i=0;i<n;i++){
            scanf("%d",&tmp);
            if (!s.empty() && s.top()==tmp){
                //cout << "debug1" << endl;
                s.pop();
            }
            else if (s.size()<m){
                //cout << "debug2" << endl;
                while (cnt!=tmp && s.size()<m){
                    s.push(cnt);
                    cnt++;
                }
                //cout << s.size() << ' ' << tmp << endl;
                if (s.size()==m){
                    //没找到这个数字就满了
                    flag=true;
                }
                //cnt==tmp相等的时候不压入
                else cnt++;
            }
            else{
                //cout << "debug3" << endl;
                flag=true;
            }
        }
        if (!flag) printf("YES\n");
        else printf("NO\n");
    }
    
}

7-22 堆栈模拟队列，能模拟的队列容量 <= 两个堆栈容量之和，可以参考232.用栈实现队列中的图，主要想法是通过两个栈的倒换改变元素的顺序，而225. 用队列实现栈中可以通过先入队再出队的方法备份前面的元素。猫狗收养问题是典型的队列应用

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

class myQ{
public:
    stack<int> sin;
    stack<int> sout;
    int inSize,outSize,inCap,outCap;
    //必须小的那个栈做输入栈,大的栈做输出栈,因为输入栈满了之后要倒入输出栈
    myQ(int max,int min):inCap(min),outCap(max),inSize(0),outSize(0){};
    void AddQ(int x){
        //输入的元素放入in,如果满了就看看能不能放到sout
        if (inSize<inCap){
            sin.push(x);
            inSize++;
        }
        else{
            //inSize==inCap
            if (!sout.empty()){ //这里不能用outCap==outSize判断
                cout << "ERROR:Full" << endl;
                return;
            }
            //倒入输入栈
            while (!sin.empty()){
                int x=sin.top();sin.pop();
                sout.push(x);
                outSize++;
            }
            sin.push(x);
            inSize=1;
        }
    }
    void DeleteQ(){
        int x;
        //输出输出栈的内容,如果没有的话就看看输入栈
        if (!sout.empty()){
            x=sout.top();sout.pop();
            outSize--;
        }
        else{
            if (sin.empty()){
                cout << "ERROR:Empty" << endl;
                return;
            }
            while (!sin.empty()){
                int x=sin.top();sin.pop();
                sout.push(x);
                outSize++;
            }
            inSize=0;
            x=sout.top();sout.pop();
            outSize--;
        }
        cout << x << endl;
    }
};

int main(){
    int n1,n2;
    myQ* q;
    cin >> n1 >> n2;
    if (n1>n2) q=new myQ(n1,n2);
    else q=new myQ(n2,n1);
    int x;
    char c;
    cin >> c;
    while (c!='T'){
        if (c=='A'){
            cin >> x;
            q->AddQ(x);
        }
        else if (c=='D') q->DeleteQ();
        //cout << "inSize=" << q->inSize << "outSize=" << q->outSize << endl;
        cin >> c;
    }
}

下面是中缀表达式转后缀表达式，后缀表达式求值直接用堆栈可解决，前缀表达式求值只需读入全部字符串，再倒着遍历字符，处理方法与后缀表达式求值类似。后缀表达式求值，前缀表达式求值一定要熟练，视频在这，中缀表达式求值可以先写出下面的转换，再利用堆栈计算转换后的后缀表达式

//数字的相对顺序不变,计算符号的相对顺序改变
//存储"等待中"的运算符号,将当前运算符号与"等待中"的最后一个运算符号比较
//如果当前运算符优先级低,那么栈内优先级高的就可以输出
//左括号在外面优先级最高,在栈内优先级最低
//遇到右括号,输出到左括号结束
//同一优先级堆栈内的先输出

/*
测试点

序号    输入                     输出                                   说明
0    2+3*(7-4)+8/4            2 3 7 4 - * + 8 4 / +            正常测试6种运算符
1    ((2+3)*4-(8+2))/5        2 3 + 4 * 8 2 + - 5 /            嵌套括号
2    1314+25.5*12             1314 25.5 12 * +                 运算数超过1位整数且有非整数出现
3    -2*(+3)                  -2 3 *                           运算数前有正负号
4    123                      123                              只有一个数字

*/

#include <stack>
#include <map>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main(){
    //m是计算符的优先级,( 放入堆栈内优先级最低
    map<char,int> m={{'(',0},{')',0},{'+',1},{'-',1},{'*',2},{'/',2}};
    string str;
    cin >> str;
    stack<char> s;
    string num; //存储数字
    vector<string> res; //存储输出结果
    for (int i=0,len=str.size();i<len;i++){
        //下面第一个if是得到数字,这个是细节最多的地方
        if(isdigit(str[i]) || (((i==0 || str[i-1]=='(')) && (m[str[i]]==1))){
            //单纯数字                 //({正负号}{数字})的情况,即序号3的输入
            if(str[i]!='+') num={str[i]};
            while(isdigit(str[i+1]) || str[i+1]=='.'){
                num+=str[i+1];
                i++;
            }
            res.push_back(num);
            num="";
        }
        else{
            if (str[i]=='(') s.push(str[i]);
            else if (str[i]==')'){
                while (!s.empty() && s.top()!='('){
                    res.push_back({s.top()});s.pop();
                }
                s.pop();
            }
			else{
				//						注意这里是<=
				while(!s.empty()&&m[str[i]]<=m[s.top()]){//这里需要注意，如果是空栈，直接压栈即可，如果栈顶元素的优先级大于等于s【i】，需要先将栈顶元素放入v中，再进行压栈，这里的循环是重点，需要掌握。
					res.push_back({s.top()});s.pop();
				}
				s.push(str[i]);
            }
        }
    }
    while (!s.empty()){
        res.push_back({s.top()});s.pop();
    }
    cout << res[0];
    for (int i=1,len=res.size();i<len;i++) cout << ' ' << res[i];
    return 0;
}


#include <iostream>
#define MAXSIZE 10000
using namespace std;

template<typename T>
class LNode{ //顺序实现
    public:
        T data[MAXSIZE];
        int last; //最后一个元素的下标
    LNode():last(-1){}; //这里必须是-1,添加一个元素后是0,满足insert
    int find(T x){
        int i=0;
        while (i<=last && data[i]!=x) x++;
        if (i>last) return -1;
        return i;
    }
    void insert(int i,T x){
        int j;
        // 注意下面的两个判定
        if (last==MAXSIZE-1){
            cout << "表满" << endl;
            return;
        }
        if (i<0 || i>last+1){ //可以插到last+1,不能插到last+2
            cout << "位置不合法" << endl;
            return;
        }
        for (j=last;j>=i;j--) data[j+1]=data[j]; //注意遍历顺序及等号的有无
        data[i]=x;
        last++;
    }
    void Delete(int i){
        if (i<0 || i>last){
            cout << "元素不存在" << endl;
            return;
        }
        for (int j=i;j<last;j++){ //注意遍历顺序
            data[j]=data[j+1];
        }
        last--;

    }
};
template<typename T>
class lNode{ //链表实现
    public:
    T data;
    lNode* next;
    lNode(T x):data(x),next(nullptr){};
    int length(){
        int i=1;
        lNode* head=this;
        while (head->next){
            i++;
            head=head->next;
        }
        return i;
    }
    lNode* insert(int i,T x){
        lNode* s=new lNode(x);
        if (i==0){
            //要分头部和非头部
            s->next=this;
            return s;
        }
        lNode* p=findKth(i-1); //△插入删除都是找i-1个元素△
        if (!p){
            cout << "参数错误" << endl;
            return this;
        }
        s->next=p->next;
        p->next=s;
        return this;
    }
    lNode* findX(T x){
        lNode* head=this;
        while (head && head->data!=x){
            head=head->next;
        }
        return head; //不需要if判断,空了自然就返回null
    }
    lNode* findKth(int k){
        int i=0;
        lNode* head=this;
        while (head && i<k){
            head=head->next;
            i++;
        }
        if (i==k) return head;
        return nullptr;
    }
    lNode* deleteKth(int k){
        if (k==0){
            if (this==nullptr){
                cout << "头节点为空" << endl;
                return nullptr;
            }
            else{
                lNode* head=this;
                lNode* s=head->next;
                delete head;
                return s;
            }
        }
        lNode* p=findKth(k-1);
        if (!p){
            cout << k-1 << " 节点不存在" << endl;
            return this;
        }
        if (!p->next){
            cout << k << " 节点不存在" << endl;
            return this;
        }
        lNode* s=p->next; //要删除的是p->next
        p->next=s->next;
        delete s;
        return this;
    }


};
template<typename T>
class GNode{ //广义表,表中的元素是另一个广义表或单元素,可以用union
    int tag; //0表示单元素
    union{
        T data;
        GNode* subList;
    }UReign;
    GNode* next;
};

template<typename T>
class Stack{
    //后入先出,数组实现
    T data[MAXSIZE];
    int top;
    Stack():top(-1){};
    void push(T x){
        if (top==MAXSIZE-1){
            cout << "栈满" << endl;
            return;
        }
        data[++top]=x;
    }
    T pop(){
        if (top==-1){
            cout << "栈空" << endl;
            return nullptr;
        }
        return data[top--];
    }


};

template<typename T>
class DStack{
    //一个数组实现两个堆栈
    T data[MAXSIZE];
    int top1;
    int top2;
    DStack():top1(-1),top2(MAXSIZE){};
    void push(T x,int tag){
        //tag是放哪个堆
        if (top2-top1==1){
            //比如两个指针挨在一起放不下
            cout << "栈满" << endl;
            return;
        }
        if (tag==1) data[++top1]=x;
        else data[--top2]=x;
    }
    T pop(int tag){
        if (tag==1){
            if (top1==-1){
                cout << "栈空" << endl;
                return nullptr;
            }
            else return data[top1--];
        }
        else{
            if (top2==MAXSIZE){
                cout << "栈空" << endl;
                return nullptr;
            }
            else return data[top2++];
        }
    }
};

template<typename T>
class SNode{
    //△链表实现堆栈,top必须是头节点△
    T data;
    SNode* next;
    SNode():next(nullptr){}; //头节点没有信息,dummy节点
    SNode(int x):data(x),next(nullptr){};
    bool isEmpty(){
        return next==nullptr;
    }
    void push(T x){
        SNode* s=new SNode(x);
        s->next=this->next;
        this->next=s;
    }
    T pop(){
        if (this->next==nullptr){
            cout << "栈空" << endl;
            return nullptr;
        }
        else{
            SNode* s=this->next;
            this->next=s->next;
            T d=s->data;
            delete s;
            return d;
        }
    }
};

template<typename T>
class Queue{
    T data[MAXSIZE];
    int front,rear; //△front是第一个元素前一个索引,rear是最后一个索引△
    //顺环队列rear和front相等时无法判断队列是空还是满
    //不放满队列可以解决
    Queue():front(0),rear(0){};
    void add(T x){  //△下一个放的位置是(rear+1)%MAXSIZE△
        if ((rear+1)%MAXSIZE==front){
            cout << "队列满" << endl;
            return;
        }
        rear=(rear+1)%MAXSIZE;
        data[rear]=x;
    }
    T DeleteX(){
        if (front==rear){
            cout << "队列空" << endl;
            return nullptr;
        }
        front=(front+1)%MAXSIZE;
        return data[front];
    }
};
template<typename T>
class node{ //链表节点
    T data;
    node* next;
    node(T x):data(x),next(nullptr){};
};
template<typename T>
class QNode{
    //链表实现queue
    //front做删除操作,rear做删除操作,链表头节点删掉之后找不到下一个,因此不能做front
    //只能头节点做front,尾结点做rear
    //△实现插入删除注意判断队列是否为空,很重要△
    node<T>* rear;
    node<T>* front;
    QNode():rear(nullptr),front(nullptr){};
    bool isEmpty(){
        return front==nullptr;
    }

    void add(T x){
        node<T>* s=new node<T>(x);
        if (isEmpty()){
            rear=front=s;
            return;
        }
        else{
            rear->next=s;
            rear=s;
        }
        return;
    }
    T Delete(){
        if (isEmpty()){
            cout << "队列空" << endl;
            return nullptr;
        }
        node<T>* s=front;
        if (front==rear){
            //队列只有一个元素
            front=nullptr;
            rear=nullptr;
        }
        else front=s->next;
        T d=s->data;
        delete s;
        return d;
    }
};

int main(){

    //栈实现中缀表达式
    //https://www.bilibili.com/video/BV1JW411i731?p=20&spm_id_from=pageDriver&vd_source=6c26f427606a59575440e9bc6cec44af&t=192.9
    lNode<int>* l=new lNode<int>(0);
    //LNode<int>* l=new LNode<int>();
    cout << l->data << ' ' << l->length() << endl;
    l=l->insert(0,1);
    l=l->insert(0,2);
    cout << l->data << ' ' << l->length() << endl;
    //l->insert(0,1);
    //l->insert(0,2);
    l=l->insert(0,3);
    l=l->insert(0,4);
    l=l->insert(0,5);
    l=l->deleteKth(0);
    cout << l->data << ' ' << l->length() << endl;

}
_森罗万象
关注
专栏目录
链表，堆栈与队列
sesiria的博客
04-11 425
一，链表 定义： struct link_node { int value; struct link_node * next; }; 1. 判断链表是否有没有环 使用两个快慢指针 慢指针往后面以动一个节点 快指针每次移动两个节点 // check whether the link list is a ring // 1 for true, and 0 for false. int isRing(struct link_node* head) { if (head ==
链表 堆栈 队列
shanchangyi的博客
08-17 473
1、链表  的创建 加入 删除 遍历 等 ······      #include #include typedef struct student { int num; struct student *next; }node; node* creat(); int length(node* n); void print(node* n); node* insert(no
数据结构：链表、栈、队列
最新发布
2401_84247058的博客
08-14 1755
本文介绍了数据结构中链表、栈、队列的相关知识，并给出了定义和使用示例。
数据结构之链表堆栈队列
weixin_34072159的博客
03-06 216
在计算机科学中，数据结构(data structure)是计算机中存储、组织数据的方式。 数据结构意味着接口或封装：一个数据结构可被视为两个函数之间的接口，或者是由数据类型联合组成的存储内容的访问方法封装。 ---wikipedia.org 存储线性数据集合，都有顺序结构和链式结构 链表 链表是线性数据集合的链式表示方法（数组是顺序表示方法） 链表（Linked list）是一种常见的基础...
链表，队列，堆栈
AlexTan_的博客
04-26 894
一. 链表 1.定义         链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在由一个个节点组成，每个节点（node）中储存着数据变量（data）和指针变量（node next），又有一个头节点（head）连接下面的节点，而最后一个节点指向空（null）。可以在链表类中定义增加，删除，插入，遍历，修改等方法，故常用来储存
C++(数据结构)：链表
08-03
C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 ...
嵌入式数据结构链表队列堆栈
07-17
嵌入式常用数据结构-链表、队列、堆栈、可删除key值链表、优先级队列，消息队列
数据结构 链表 队列 堆栈
06-27
完整代码 正确产生结果 三个类分开写 class linklist { protected: struct node { int data; node *next; }; node *head; int length; public:
数据结构算法集---C++语言实现.rar_queue stack_堆栈 栈_数据结构 队列_链表_队列
07-15
总的来说，这个C++数据结构算法集提供了对基本数据结构和算法的实现，包括堆栈、队列和链表，这对于学习和理解数据结构及其在实际编程中的应用非常有帮助。掌握这些基础知识将有助于提升编程能力，解决更复杂的问题...
Java数据结构详解：链表、栈、队列与树实现详解
本文将深入探讨Java编程语言中四种基本数据结构：链表、栈、队列和树的实现方法。首先，我们从链表开始，它是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的引用。节点定义的关键在于`...
堆，栈，队列，链表，数组
YJF@HZ的博客
10-28 1671
堆和栈从操作系统和数据结构中加以区别： c
数据结构学习之栈队列链表
Yucohny
02-22 254
文章目录一、链表1.单向链表2.双向链表二、队列三、栈 一、链表 1.单向链表 单项链表应至少满足这样的功能： 1.O(1)O(1)O(1)添加元素 在链表末尾添加元素，移动tailtailtail指针，建立新节点，赋值。 2.O(n)O(n)O(n)插入元素 从链表头开始枚举，直到枚举到需要插入元素的位置。改变指针指向，插入元素。 3.O(n)O(n)O(n)删除元素 从链表头开始枚举，直到枚举到需要删除元素的位置。改变指针指向，删除元素。 4.枚举所有元素 从链表头开始枚举，直到末尾。 另外注意，单向链
python 实现链表、堆栈、队列
weixin_46707493的博客
02-17 1332
目录： 一、实现单链表 二、通过链表实现堆栈 三、通过链表实现队列 一、实现链表： class Node(): """结点类""" def __init__(self, data): self.data = data self.next = None class LinkList(): """链表类""" def __init__(self,node = None): self.__head = node
链表 栈 队列 堆 二叉树 （超级详细）
qq_53217755的博客
12-20 1006
目录 链表 栈 队列 堆 二叉树 链表 栈 队列 堆 二叉树
数据结构（栈/队列/链表）
weixin_47667133的博客
07-20 974
线性数据结构 2. 什么叫做数据结构 数据结构是计算机存储、组织数据的方式。指的是相互之间存在一种或多种特定关系的数据元素的集合。 ​ – 百度百科 可比喻成一个企业的组织结构，组织结构其实就是部门与部门之间的关系结构。 数据结构就是用来描述数据与数据之间的关系 线性和非线性数据结构 线性结构：数据元素之间一对一的关系 非线性结构：数据元素之间一对多的关系 存储方式 顺序存储：Set、Array 散列存储：Map、Object
链表【+逆序链表】、循环队列、堆栈讲解（头插法和尾插法）
m0_51429770的博客
05-31 3098
链表是一种常用的数据结构。相较于数组，链表的好处在于可以动态地分配内存空间，因此可以适应更为灵活的内存需求。数据域和指针域。数据域存储节点的数据，指针域指向下一个节点。将所有的节点连接起来，就形成了一个链表。可以动态地分配内存空间，不受固定大小的限制；插入和删除操作效率高，时间复杂度为O(1)；可以轻松地实现栈、队列等数据结构。随机访问不方便，需要遍历整个链表；内存空间占用较大，因为每个节点都需要额外的指针域；不支持快速排序等高级算法。队列是一种特殊的线性表结构，它只允许在队尾。
数据结构复习：链表、数组、栈、队列、哈希表、堆、二叉树
weixin_47723114的博客
12-06 605
饺子的数据结构复习章节：链表、数组、栈、队列、哈希表、堆、二叉树等知识点简单回顾
Java数据结构与算法：链表、堆栈、队列、二叉树解析
"该资源是吴进主讲的‘第十三课数据结构与算法(下)’教程，属于Java经典教程系列，主要讲解了数据结构的相关概念和实现，包括链表、队列、栈和二叉树等动态数据结构。此外，还提到了自引用类的概念。" 在这篇教程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_森罗万象

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值