链栈+队列

最新推荐文章于 2024-08-22 21:24:01 发布
最新推荐文章于 2024-08-22 21:24:01 发布
阅读量848 收藏 21
点赞数 21
分类专栏： 算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55078860/article/details/135917707
版权

一、链栈

1.定义

栈是后进先出的线性序列，也是一种线性表，操作受限的线性表，只能在一端进行进出操作，进出的一端被称为栈顶，另一端被称为栈底。栈可以采用顺序存储，也可以采用链式存储，分别被称为顺序栈和链栈。

链栈数据结构定义

typedef struct Snode{
    ElemType data;//数据域
    struct Snode *next;//指向下一个结点的指针
}Snode,*LinkSnode;

2.初始化

初始化一个空栈，链栈是不需要头结点的，只需要让栈顶指针为空即可（栈顶指针S就是最上方那个元素）。

bool InitStack(LinkSnode &S){
    S=NULL;
    return true;
}

3.入栈

将新元素结点压入栈顶，将新元素结点插入到第一个节点的前面，然后修改栈顶指针。

bool Push(LinkSnode &S,int e){
    LinkSnode p;
    p=new Snode;
    p->data=e;
    p->next=S;
    S=p;
    return true;
}

4.出栈

将栈顶元素删除，栈顶指针指向下一个结点，然后释放空间。

bool Pop(LinkSnode &S,int &e){
    if(S==NULL)
        return false;
    LinkSnode p;
    p=S;//用p存S，然后delete p，不能delete S
    e=S->data;
    S=S->next;
    delete p;
    return true;
}

5.取栈顶元素

int GetTop(LinkSnode S){
    if(S==NULL)
        return -1;
    return S->data;
}

二、队列

1.定义

队列是先进先出的线性序列，也是一种线性表，操作受限的线性表，只能在两端操作：从一端进，从另一端出。进的一端被称为队尾（rear），出的一端被称为队头（front）。队列可以顺序存储，也可以链式存储。

顺序存储静态定义

typedef struct sqQueue{
    ElemType data[Maxsize];
    int front,rear;
}sqQueue

顺序存储动态定义

typedef struct sqQueue{
    ElemType *base;//使用基地址
    int front,rear;
}sqQueue
Q.base=new int[Maxsize];

2.假溢出

明明有空间，却出现了队满的情况，这种情况称为“假溢出”。

使用循环队列可以解决这个假溢出的问题。 

3.队空

循环队列队空的判定条件：Q.front==Q.rear（Q.front和Q.rear指向同一个位置）

4.队满

循环队列队满的判定条件：（Q.rear+1）%Maxsize==Q.front（尾指针的下一个状态是头指针，浪费了一个空间）

5.入队

入队时，首先将元素x放入Q.rear所指空间，然后Q.rear后移一位。

Q.base[Q.rear]=x;
Q.rear=(Q.rear+1)%Maxsize;

6.出队

先用变量保存队头元素，然后队头Q.front后移一位。

e=Q.base[Q.front]; 
Q.front=(Q.front+1)%Maxsize;

7.队列长度

循环队列中的内容实际上为Q.front到Q.rear-1这一区间的数据元素。

Q.rear>=Q.front：元素个数为Q.rear-Q.front；

Q.rear<Q.front：元素个数为Q.rear-Q.front+MaxSize；

8.全部代码 

typedef struct sqQueue{
    int *base;
    int front,rear;//指针域
}sqQueue;

bool InitQueue(sqQueue &Q){
    Q.base=new int[Maxsize];
    if(!Q.base)
        return false;
    Q.rear=Q.front=0;
    return true;
}

bool EnQueue(sqQueue &Q,int e){
    if((Q.rear+1)%Maxsize==Q.front)
        return false;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%Maxsize;
    return true;
}

bool DnQueue(sqQueue &Q,int &e){
    if(Q.rear==Q.front)
        return false;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%Maxsize;
    return true;
}

int GetHead(sqQueue Q){
    if(Q.rear!=Q.front)
        return Q.base[Q.front];
    return -1;
}

int QueueLength(sqQueue Q){
    return (Q.rear-Q.front+Maxsize)%Maxsize;
}

三、题目

1.表达式括号匹配

 这道题很显然用栈就可以解决了。

#include<iostream>
#include<cstdio>
#include <cstring>
#define ll long long
using namespace std;

typedef struct Snode{
    char data;
    struct Snode *next;
}Snode,*LinkSnode;

void Push(LinkSnode &S,char e){
    LinkSnode p;
    p=new Snode;
    p->data=e;
    p->next=S;
    S=p;
}

bool Pop(LinkSnode &S){
    if(S==NULL)
        return false;
    LinkSnode p;
    p=S;//用p存S，然后delete p，不能delete S
    S=S->next;
    delete p;
    return true;
}

int main()
{
    LinkSnode S;
    char ch;
    int flag=0;//flag为0式子正确，flag为1式子错误
    S=NULL;
    while(ch != '@'){
        scanf("%c",&ch);
        if(ch=='('){
            Push(S,ch);
        }
        if(ch==')'){
            if(!Pop(S)){//如果栈为空，没有(，式子错误
                flag=1;
            }
        }
    }
    if(flag==0&&S==NULL){//以上判断会漏掉(的情况
       printf("YES");
    }
    else{
       printf("NO");
    }
}

在网上看到了一个更简单的代码

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int top;
int main()
{
	char ch;
	while(ch!='@')
	{
		scanf("%c",&ch);
		if(ch=='(')
			top++;
		if(ch==')')
			if(top>0)
				top--;
			else
			{
				cout<<"NO";
				return 0; 
			}
	}
	if(top==0)
		printf("YES");
	else
		printf("NO");
}

2.Rails

某城市有一个火车站，有n节车厢从A方向驶入车站，按进站的顺序编号为1到n.你的任务是判断是否能让它们按照某种特定的顺序进入B方向的铁轨并驶入车站。例如，出栈顺序（5 4 1 2 3）是不可能的，但是（5 4 3 2 1）是可能的。

 显然，这个火车站是一个中间栈，从A方向进栈，从B方向出栈。题目不难，但是这个输入输出让我看了半天才看明白。

#include<bits/stdc++.h>
using namespace std;
int target[1000];
int n;
typedef struct Snode{
    int data;//数据域
    struct Snode *next;//指向下一个结点的指针
}Snode,*LinkSnode;
void Push(LinkSnode &S,int e){
    LinkSnode p;
    p=new Snode;
    p->data=e;
    p->next=S;
    S=p;
}
bool Pop(LinkSnode &S){
    if(S==NULL)
        return false;
    LinkSnode p;
    p=S;//用p存S，然后delete p，不能delete S
    S=S->next;
    delete p;
    return true;
}
int main()
{
    LinkSnode S;
    S=NULL;
	while (scanf("%d",&n)==1 && n) {
		while (1) {
			if (scanf("%d",&target[0])==1&&!target[0]) break;
			for (int i = 1; i < n; i++) {
				scanf("%d",&target[i]);
			}
			int a=0,b=0;
			while(b<n){
			    if(target[b]==(a+1)){//如果从A过来的车厢是B所期望的，直接b++
                    b++;
                    a++;
			    }
			    else{//否则看栈顶元素
                    if(S!=NULL&&S->data==target[b]){//如果栈顶元素是B所期望的，出栈
                        b++;
                        Pop(S);
                    }
                    else{//否则
                        if(a<n){
                            Push(S,a+1);//将A过来的车厢压入栈，看下一个来的车厢
                            a++;
                        }
                        else{//A过来的车厢都在中间栈了，但栈顶元素不是B所期望的，说明不可能了
                            break;
                        }
                    }
			    }
			}
			if (S==NULL) {
				cout << "Yes" << endl;
			}
			else {
				cout << "No" << endl;
				while(Pop(S));
			}
		}
		cout << endl;
	}
	return 0;
}

3.Matrix Chain Multiplication

 

这题不需要考虑括号是否匹配的, 即不会有 (AB)) 的情况， 碰到字母就进栈, 碰到 ) 就出栈两个数, 进行运算后入栈。栈里的数据要保存行和列，可以用map。

这题有个问题，表达式的输入有可能是空行， 对此必须不作处理。没注意这点很可能输出0，就会一直wa。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int rows[26],cols[26];
int n;
typedef struct Snode{
    map<string,int> data;//数据域
    struct Snode *next;//指向下一个结点的指针
}Snode,*LinkSnode;
void Push(LinkSnode &S,map<string,int> e){
    LinkSnode p;
    p=new Snode;
    p->data=e;
    p->next=S;
    S=p;
}
bool Pop(LinkSnode &S,map<string,int> &e){
    if(S==NULL)
        return false;
    LinkSnode p;
    p=S;//用p存S，然后delete p，不能delete S
    e=S->data;
    S=S->next;
    delete p;
    return true;
}
int main()
{
    LinkSnode S;
    char ch;
    string str;
    map<string,int> x,y;
    int flag=1;
    ll sum=0;
    S=NULL;
	cin>>n;
	for(int i=0;i<n;i++){
        cin.ignore();
        scanf("%c",&ch);
        scanf("%d",&rows[int(ch)-65]);
        scanf("%d",&cols[int(ch)-65]);
	}
	while(getline(cin, str)){
        if(str=="")continue;
        else{
            for(int i=0;i<str.size();i++){
                if(str[i]==')'){
                    Pop(S,y);Pop(S,x);
                    if(x["col"]!=y["row"]){
                        flag=0;
                        break;
                    }
                    else{
                        sum+=x["row"]*x["col"]*y["col"];//计算相乘次数
                        x["col"]=y["col"];
                        Push(S,x);//将xy相乘后的新的矩阵存进去
                    }
                }
                else if(str[i]=='(') continue;
                else{
                    x["row"]=rows[int(str[i])-65];x["col"]=cols[int(str[i])-65];
                    Push(S,x);
                }
            }
            if(flag==0){
                printf("error\n");
                flag=1;
            }
            else printf("%d\n",sum);//不管是一个矩阵还是一个以上的矩阵，最后栈里只有一个矩阵
            S=NULL;//清空栈
            sum=0;
        }
	}
	return 0;
}

4.Printer Queue

 

这道题根据题目就知道用队列来解决，解决思路很简单，通过代码对应解释就能明白。 

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int Maxsize=105;
int n,m;
typedef struct sqQueue{
    int *base;
    int front,rear;//指针域
}sqQueue;

bool InitQueue(sqQueue &Q){
    Q.base=new int[Maxsize];
    if(!Q.base)
        return false;
    Q.rear=Q.front=0;
    return true;
}

bool EnQueue(sqQueue &Q,int e){
    if((Q.rear+1)%Maxsize==Q.front)
        return false;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%Maxsize;
    return true;
}

bool DnQueue(sqQueue &Q,int &e){
    if(Q.rear==Q.front)
        return false;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%Maxsize;
    return true;
}
int findMax(sqQueue Q){//获得队列中的最大值
    int i=Q.front;
    int maxn=0;
    while(i!=Q.rear){
        if(maxn<Q.base[i])maxn=Q.base[i];
        i=(i+1)%Maxsize;
    }
    return maxn;
}

int main()
{
    int T,e,maxQ;
    sqQueue Q;
    scanf("%d",&T);
    for(int i=0;i<T;i++){
        int sum=0;
        InitQueue(Q);
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++){
            scanf("%d",&e);
            EnQueue(Q,e);
        }
        maxQ=findMax(Q);
        while(1){
            if(Q.base[Q.front]==maxQ){//如果队头是队列中优先级最高的
                sum+=1;//完成了一个打印任务
                if(Q.front==m){printf("%d\n",sum);break;}//如果队头是要完成的任务，则结束循环
                DnQueue(Q,e);//出队
                maxQ=findMax(Q);//获取新的最大值
            }
            else{
                if(Q.front==m){//如果要放队尾的是要完成的任务
                    DnQueue(Q,e);
                    EnQueue(Q,e);//放到队尾去
                    m=(Q.rear-1+Maxsize)%Maxsize;//更新任务编号
                }else{DnQueue(Q,e);EnQueue(Q,e);}//直接出队放入队尾
            }
        }
    }
	return 0;
}

 

随便想的
关注
  • 21
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
栈和队列（顺序栈、链栈、队列、循环队列、链队列）
cp_Mark的博客
09-18 4703
栈的定义 定义：栈是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称后进先出(Last In First Out)的线性表，简称LIFO结构。 栈的插入操作，叫作进栈（Push），也称压栈、入栈。栈的删除操作，叫作出栈（Pop），也有的叫作弹栈。示意图如下： 栈的抽象数据类型 栈本身就是一个线性表，所以关于...
链表&链栈&队列
QIAN_HUAI
01-02 235
数据结构线性存储一级目录二级目录三级目录 一级目录 链表： #if 0 #include<iostream> using namespace std; typedef int Status; //typedef struct { // char num[8]; // char name[8]; // int score; //}ElemType; typedef int ElemType; typedef struct Lnode { ElemType data; struct Lno
停车场管理系统(C语言顺序栈+链栈+链队列)
热门推荐
weixin_55797565的博客
04-20 1万+
停车场管理系统(C语言---车库顺序栈+临时链栈+排队车道链队列)
链栈 链队列 share
b2utyyomi的博客
11-22 284
发现自己好像越来越low了 没四儿 开心就好 ///链栈 #include using namespace std; typedef struct node///几种不同的打包方式 自己总是糊里糊涂的 多看看吧 { int data; node *next; node *top; }LinkStack; // typedef struct { node *
链栈和数组队列
qq_40386321的博客
11-27 127
main.cpp: #include <stdio.h> #include <stdlib.h> typedef int TYPE; struct node { TYPE data; node* next; }; node* node_create() { node* temp = (node*)malloc(sizeof(node)); temp->data...
链栈与链队列
weixin_45461859的博客
12-27 886
链栈 链栈的定义 栈的链式存储结构 链栈：即用链表实现栈存储结构 栈顶：允许插入和删除的一端（top） 栈底：不同于栈顶的另外一端（bottom） 空栈：不含任何元素的栈 链栈实际上就是一个只能采用头插法插入或删除数据的链表 //链栈表示 struct link{ int data; struct link *next; }; //链栈初始化 void initstack(struct ...
链表链栈链队列
shlshlshk的博客
06-29 112
1.分配空间 (分配类型 *)malloc(分配元素个数 *sizeof(分配类型)) 链表 链栈 链队列 节点 top指针 count计数 front指针 rear指针 初始化 1. *L 分配空间 2.分配失败 3.分配成功 1. ...
java链队列图解_顺序栈,链栈,队列java实现
weixin_35612315的博客
02-25 117
顺序栈/*** 顺序栈* */public class SqStack {//栈的大小private int maxSize;//栈顶指针private int top;private char[] stack;public SqStack(int size){maxSize = size;top = -1;stack = new char[maxSize];}//压栈public void pu...
C语言实现顺序栈 链栈 循环队列 链队列的基本操作
palepale
10-05 1021
顺序栈 #include <stdio.h> #include <stdlib.h> #define StackInitSize 10 #define StackIncrement 5 typedef int SElemType; typedef struct { SElemType *base; int top; int stacksize; }SqStack; v...
顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip
08-16
本资料包"顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip"涵盖了这四种数据结构的基本操作，包括入队、出队、入栈、出栈等核心算法。 1. **顺序栈**： - 顺序栈是一种基于数组实现的栈，其元素存储在连续...
图结构期末总结期末总结期末总结
01-24
"图结构总结" 图结构是数据结构中的一种重要概念，用于描述顶点之间的关系。图结构由顶点的有穷非空集合和顶点之间的边的集合组成，记为 G = (V, E)。其中，V 表示顶点的集合，E 表示边的集合。...
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
### 数据结构C++：顺序栈、链栈、循环队列、链队列的主要操作 #### 一、概述 本文档提供了使用C++编程语言实现的数据结构中的栈与队列的操作详解，具体包括顺序栈、链栈、循环队列、链队列四种结构的基本操作，并...
C++数据结构实验_实现共享栈，链栈，循环队列，链队列
12-07
在这个实验中，我们将关注四种特定的数据结构：共享栈、链栈、循环队列和链队列。这些数据结构在各种算法和应用程序中都有广泛应用。 首先，我们来看共享栈（Shared Stack）。共享栈是一种特殊的栈，其中多个线程...
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 350
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 848
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 771
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
算法025：前缀和
最新发布
m0_62319039的博客
08-22 203
算法025：前缀和
链栈与队列：栈的初始化与比较
"链栈基本算法-栈和队列" 栈和队列是两种重要的数据结构，它们在计算机科学和编程中有着广泛的应用。栈被称为“后进先出”（LIFO，Last In First Out）的数据结构，而队列则是“先进先出”（FIFO，First In First ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值