A - 数据结构实验之栈与队列一:进制转换
Description
输入一个十进制非负整数,将其转换成对应的 R (2 <= R <= 9) 进制数,并输出。
Input
第一行输入需要转换的十进制非负整数;
第二行输入 R。
Output
输出转换所得的 R 进制数。
Sample
Input
1279
8
Output
2377
顺序栈方法
#include<stdio.h>
#include<stdlib.h>
#define N 100
typedef struct
{
int *base;
int *top;
int len;
}stack;
stack initstack()
{
stack s;
s.top=(int *)malloc(N * sizeof(int));
s.base=s.top;
s.len=0;
return s;
}
int pop(stack *s)
{
int e;
e=*(s->top-1);
s->top--;
s->len--;
return e;
}
void push(stack *s,int x)
{
*(s->top)=x;
s->top++;
s->len++;
}
int main()
{
int n,m;
stack s;
scanf("%d %d",&n,&m);
s=initstack();
if(n==0)
{
push(&s,n);
}
while(n)
{
push(&s,n%m);
n/=m;
}
while(s.len)
{
printf("%d",pop(&s));
}
return 0;
}
链栈方法
#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
int pop(stack *p)
{
int n;
node *t;
n=p->top->next->data;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
return n;
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
}
void print(stack *p)
{
while(p->top->next)
{
printf("%d",pop(p));
}
}
int main()
{
int n,m;
stack *t;
t =creatstack();
scanf("%d %d",&n,&m);
if(n==0)
{
push(t,n);
}
while(n)
{
push(t,n%m);
n/=m;
}
print(t);
return 0;
}
B - 数据结构实验之栈与队列二:一般算术表达式转换成后缀式
Description
对于一个基于二元运算符的算术表达式,转换为对应的后缀式,并输出之。
Input
输入一个算术表达式,以‘#’字符作为结束标志。
Output
输出该表达式转换所得到的后缀式。
Sample
Input
a*b+(c-d/e)*f#
Output
ab*cde/-f*+
链栈
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
char data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *s;
s=(stack *)malloc(sizeof(stack));
s->top=creatnode();
s->base=s->top;
return s;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
}
char top(stack *p)
{
char t;
t=p->top->next->data;
return t;
}
void push(stack *p,char n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int empty(Stack *t)
{
if(t->top->next==NULL)
{
return 0;
}
return 1;
}
void print(stack *p)
{
while(empty(p))
{
printf("%c",top(p));
pop(p);
}
}
int main()
{
stack *t;
char s[1000];
scanf("%s",s);
t = creatstack();
for(int i=0;s[i]!='#';i++)
{
if(s[i]=='(')
push(t,s[i]);
else if(s[i]==')')
{
while(top(t)!='(')
{
printf("%c",top(t));
pop(t);
}
pop(t);
}
else if(s[i] == '+' || s[i] == '-')
{
if(!empty(t) || top(t) == '(')
{
push(t,s[i]);
}
else
{
printf("%c",top(t));
pop(t);
push(t,s[i]);
}
}
else if(s[i] == '*' || s[i] == '/')
{
if(!empty(t)|| top(t) == '(' || top(t) == '+' || top(t) == '-')
{
push(t,s[i]);
}
else
{
printf("%c",top(t));
pop(t);
}
}
else
{
printf("%c",s[i]);
}
}
print(t);
return 0;
}
顺序栈
#include<stdio.h>
#include<stdlib.h>
typedef struct Stack
{
char *top;
char *base;
char len;
}stack;
stack creatstack()
{
stack s;
s.top=(char *)malloc(100000 * sizeof(char));
s.base=s.top;
s.len=0;
return s;
}
void pop(stack *p)
{
p->top--;
p->len--;
}
char top(stack p)
{
return *(p.top-1);
}
void push(stack *p,char n)
{
*(p->top)=n;
p->top++;
p->len++;
}
int empty(stack t)
{
if(!t.len)
{
return 0;
}
else
{
return 1;
}
}
void print(stack p)
{
while(empty(p))
{
printf("%c",top(p));
pop(&p);
}
}
int main()
{
stack t;
char s[1000];
scanf("%s",s);
t = creatstack();
for(int i=0;s[i]!='#';i++)
{
if(s[i]=='(')
push(&t,s[i]);
else if(s[i]==')')
{
while(top(t)!='(')
{
printf("%c",top(t));
pop(&t);
}
pop(&t);
}
else if(s[i] == '+' || s[i] == '-')
{
if(!empty(t) || top(t) == '(')
{
push(&t,s[i]);
}
else
{
printf("%c",top(t));
pop(&t);
push(&t,s[i]);
}
}
else if(s[i] == '*' || s[i] == '/')
{
if(!empty(t)|| top(t) == '(' || top(t) == '+' || top(t) == '-')
{
push(&t,s[i]);
}
else
{
printf("%c",top(t));
pop(&t);
}
}
else
{
printf("%c",s[i]);
}
}
print(t);
return 0;
}
C - 数据结构实验之栈与队列三:后缀式求值
Description
对于一个基于二元运算符的后缀表示式(基本操作数都是一位正整数),求其代表的算术表达式的值。
Input
输入一个算术表达式的后缀式字符串,以‘#’作为结束标志。
Output
求该后缀式所对应的算术表达式的值,并输出之。
Sample
Input
59*684/-3*+#
Output
57
Hint
基本操作数都是一位正整数!
链栈
#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *s;
s=p->top->next;
p->top->next=p->top->next->next;
free(s);
}
void push(stack *p,int c)
{
node *t;
t=creatnode();
t->data=c;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int main()
{
stack *p;
p=creatstack();
char str[1000];
scanf("%s",str);
for(int i=0;str[i]!='#';i++)
{
if(str[i]>='0' && str[i]<='9')
{
push(p,str[i]-'0');
}
else
{
int c1=top(p);
pop(p);
int c2=top(p);
pop(p);
if(str[i]=='+')
{
push(p,c2+c1);
}
else if(str[i]=='-')
{
push(p,c2-c1);
}
else if(str[i]=='*')
{
push(p,c2*c1);
}
else if(str[i]=='/')
{
push(p,c2/c1);
}
}
}
printf("%d",top(p));
return 0;
}
顺序栈
#include<stdio.h>
#include<stdlib.h>
typedef struct Stack
{
int *top;
int *base;
int len;
}stack;
stack creatstack()
{
stack p;
p.top=(int *)malloc(10001 * sizeof(int));
p.base=p.top;
p.len=0;
return p;
}
int top(stack p)
{
return *(p.top-1);
}
void pop(stack *p)
{
p->top--;
p->len--;
}
void push(stack *p,int c)
{
*(p->top)=c;
p->top++;
p->len++;
}
int main()
{
stack p;
p=creatstack();
char str[1000];
scanf("%s",str);
for(int i=0;str[i]!='#';i++)
{
if(str[i]>='0' && str[i]<='9')
{
push(&p,str[i]-'0');
}
else
{
int c1=top(p);
pop(&p);
int c2=top(p);
pop(&p);
if(str[i]=='+')
{
push(&p,c2+c1);
}
else if(str[i]=='-')
{
push(&p,c2-c1);
}
else if(str[i]=='*')
{
push(&p,c2*c1);
}
else if(str[i]=='/')
{
push(&p,c2/c1);
}
}
}
printf("%d",top(p));
return 0;
}
数据结构实验之栈与队列四:括号匹配
Description
给你一串字符,不超过50个字符,可能包括括号、数字、字母、标点符号、空格,你的任务是检查这一串字符中的( ) ,[ ],{ }是否匹配。
Input
输入数据有多组,处理到文件结束。
Output
如果匹配就输出“yes”,不匹配输出“no”
Sample
Input
sin(20+10)
{[}]
Output
yes
no
链栈
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
char data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
char top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
}
void push(stack *p,char c)
{
node *t;
t=creatnode();
t->data=c;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int isempty(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void del(stack *p)
{
while(p->top->next)
{
pop(p);
}
}
int main()
{
char str[100];
stack *p;
p=creatstack();
while(fgets(str,100,stdin))
{
int n=strlen(str);
int i=0;
for(i=0;i<n;i++)
{
if(str[i]=='[' || str[i]=='{' || str[i]=='(')
{
push(p,str[i]);
}
else if(str[i]==']' || str[i]=='}' || str[i]==')')
{
if(!isempty(p))
{
break;
}
else if(str[i]==']' && top(p)!='[')
{
break;
}
else if(str[i]=='}' && top(p)!='{')
{
break;
}
else if(str[i]=='(' && top(p)!=')')
{
break;
}
else
{
pop(p);
}
}
}
if(i==n)
{
if(!isempty(p))
{
printf("yes\n");
}
else
{
printf("no\n");
}
}
else
{
printf("no\n");
}
del(p);
}
return 0;
}
顺序栈
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct stack
{
char *top,*base;
int len;
}stack;
stack creatstack()
{
stack t;
t.top = (char *)malloc(100050*sizeof(char));
t.base = t.top;
t.len=0;
return t;
}
void push(stack *t,char x)
{
*(t->top) = x;
t->top++;
t->len++;
}
char top(stack t)
{
return *(t.top-1);
}
void pop(stack *t)
{
t->top--;
t->len--;
}
int isempty(stack t)
{
if(t.top==t.base)
{
return 0;
}
else
{
return 1;
}
}
void del(stack t)
{
while(isempty(t))
{
pop(&t);
}
}
int main()
{
char str[55];
stack p;
int n,i;
p = creatstack();
while(fgets(str,100,stdin))
{
int n=strlen(str);
int i=0;
for(i=0;i<n;i++)
{
if(str[i]=='[' || str[i]=='{' || str[i]=='(')
{
push(&p,str[i]);
}
else if(str[i]==']' || str[i]=='}' || str[i]==')')
{
if(!isempty(p))
{
break;
}
else if(str[i]==']' && top(p)!='[')
{
break;
}
else if(str[i]=='}' && top(p)!='{')
{
break;
}
else if(str[i]=='(' && top(p)!=')')
{
break;
}
else
{
pop(&p);
}
}
}
if(i==n)
{
if(!isempty(p))
{
printf("yes\n");
}
else
{
printf("no\n");
}
}
else
{
printf("no\n");
}
del(p);
}
return 0;
}
E - 数据结构实验之栈与队列五:下一较大值(一)
Description
对于包含n(1<=n<=1000)个整数的序列,对于序列中的每一元素,在序列中查找其位置之后第一个大于它的值,如果找到,输出所找到的值,否则,输出-1。
Input
输入有多组,第一行输入t(1<=t<=10),表示输入的组数;
以后是 t 组输入:每组先输入n,表示本组序列的元素个数,之后依次输入本组的n个元素。
Output
输出有多组,每组之间输出一个空行(最后一组之后没有);
每组输出按照本序列元素的顺序,依次逐行输出当前元素及其查找结果,两者之间以-->间隔。
Sample
Input
2
4 12 20 15 18
5 20 15 25 30 6
Output
12-->20
20-->-1
15-->18
18-->-1
20-->25
15-->25
25-->30
30-->-1
6-->-1
链栈
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
struct S
{
int data;
int next;
}number[20000];
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int isempty(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void del(stack *p)
{
while(isempty(p))
{
pop(p);
}
}
int main()
{
int n,m;
stack *p;
p=creatstack();
scanf("%d",&n);
while(n--)
{
scanf("%d",&m);
for(int i=0;i<m;i++)
{
scanf("%d",&number[i].data);
number[i].next=-1;
}
for(int i=0;i<m;i++)
{
if(!isempty(p))
{
push(p,i);
}
else
{
while(isempty(p) && number[i].data>number[top(p)].data)
{
number[top(p)].next=number[i].data;
pop(p);
}
push(p,i);
}
}
for(int i=0;i<m;i++)
{
printf("%d-->%d\n",number[i].data,number[i].next);
}
del(p);
if(n)
{
printf("\n");
}
}
return 0;
}
顺序栈
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Stack
{
int *top;
int *base;
int len;
}stack;
struct S
{
int data;
int next;
}number[10001];
stack creatstack()
{
stack p;
p.top=(int *)malloc(10000 * sizeof(int));
p.base=p.top;
p.len=0;
return p;
}
int top(stack t)
{
return *(t.top-1);
}
void pop(stack *t)
{
t->top--;
t->len--;
}
void push(stack *t,int x)
{
*(t->top) = x;
t->top++;
t->len++;
}
int isempty(stack t)
{
if(t.base==t.top)
{
return 0;
}
else
{
return 1;
}
}
void del(stack *t)
{
while(isempty(*t))
{
pop(t);
}
}
int main()
{
int n,m;
stack p;
p=creatstack();
scanf("%d",&n);
while(n--)
{
scanf("%d",&m);
for(int i=0;i<m;i++)
{
scanf("%d",&number[i].data);
number[i].next=-1;
}
for(int i=0;i<m;i++)
{
if(!isempty(p))
{
push(&p,i);
}
else
{
while(isempty(p) && number[i].data>number[top(p)].data)
{
number[top(p)].next=number[i].data;
pop(&p);
}
push(&p,i);
}
}
for(int i=0;i<m;i++)
{
printf("%d-->%d\n",number[i].data,number[i].next);
}
del(&p);
if(n)
{
printf("\n");
}
}
return 0;
}
G - 数据结构实验之栈与队列七:出栈序列判定
Description
给一个初始的入栈序列,其次序即为元素的入栈次序,栈顶元素可以随时出栈,每个元素只能入栈依次。输入一个入栈序列,后面依次输入多个序列,请判断这些序列是否为所给入栈序列合法的出栈序列。
例如序列1,2,3,4,5是某栈的压入顺序,序列4,5,3,2,1是该压栈序列对应的一个出栈序列,但4,3,5,1,2就不可能是该序列的出栈序列。假设压入栈的所有数字均不相等。
Input
第一行输入整数n(1<=n<=10000),表示序列的长度。
第二行输入n个整数,表示栈的压入顺序。
第三行输入整数t(1<=t<=10)。
后面依次输入t行,每行n个整数,表示要判断的每一个出栈序列。
Output
对应每个测试案例输出一行,如果由初始入栈序列可以得到该出栈序列,则输出yes,否则输出no。
Sample
Input
5
1 2 3 4 5
2
4 5 3 2 1
4 3 5 1 2
Output
yes
no
Hint
链栈
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int isempty(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clear(stack *p)
{
while(isempty(p))
{
pop(p);
}
}
int main()
{
int n,m,a[10000],b[10000];
stack *p;
p=creatstack();
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
scanf("%d",&m);
while(m--)
{
for(int i=0;i<n;i++)
{
scanf("%d",&b[i]);
}
int i,j;
i=j=0;
while(j<n)
{
if(i<n && b[j]==a[i])
{
i++;
j++;
}
else
{
if(isempty(p) && b[j]==top(p))
{
pop(p);
j++;
}
else if(i<n)
{
push(p,a[i]);
i++;
}
else
{
break;
}
}
}
if(!isempty(p))
{
printf("yes\n");
}
else
{
printf("no\n");
}
clear(p);
}
return 0;
}
顺序栈
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Stack
{
int *top;
int *base;
int len;
}stack;
stack creatstack()
{
stack p;
p.top=(int *)malloc(10000 * sizeof(int));
p.base=p.top;
p.len=0;
return p;
}
int top(stack p)
{
return *(p.top-1);
}
void pop(stack *p)
{
p->top--;
p->len--;
}
void push(stack *p,int n)
{
*(p->top)=n;
p->top++;
p->len++;
}
int isempty(stack p)
{
if(p.base==p.top)
{
return 0;
}
else
{
return 1;
}
}
void clear(stack *p)
{
while(isempty(*p))
{
pop(p);
}
}
int main()
{
int n,m,a[10000],b[10000];
stack p;
p=creatstack();
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
scanf("%d",&m);
while(m--)
{
for(int i=0;i<n;i++)
{
scanf("%d",&b[i]);
}
int i,j;
i=j=0;
while(j<n)
{
if(i<n && b[j]==a[i])
{
i++;
j++;
}
else
{
if(isempty(p) && b[j]==top(p))
{
pop(&p);
j++;
}
else if(i<n)
{
push(&p,a[i]);
i++;
}
else
{
break;
}
}
}
if(!isempty(p))
{
printf("yes\n");
}
else
{
printf("no\n");
}
clear(&p);
}
return 0;
}
H - 数据结构实验之栈与队列八:栈的基本操作
Description
堆栈是一种基本的数据结构。堆栈具有两种基本操作方式,push 和 pop。push一个值会将其压入栈顶,而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。
Input
首先输入整数t(1 <= t <= 10),代表测试的组数,以后是 t 组输入。
对于每组测试数据,第一行输入两个正整数 m(1 <= m <= 100)、n(1 <= n <= 1000),其中m代表当前栈的最大长度,n代表本组测试下面要输入的操作数。 而后的 n 行,每行的第一个字符可能是'P’或者'O’或者'A’;如果是'P’,后面还会跟着一个整数,表示把这个数据压入堆栈;如果是'O’,表示栈顶元素出栈;如果是'A',表示询问当前栈顶的值'。
Output
对于每组测试数据,根据其中的命令字符来处理堆栈;
(1)对所有的'P'操作,如果栈满输出'F',否则完成压栈操作;
(2)对所有的'A'操作,如果栈空,则输出'E',否则输出当时栈顶的值;
(3)对所有的'O'操作,如果栈空,则输出'E',否则输出栈顶元素的值,并让其出栈;
每个输出占据一行,每组测试数据(最后一组除外)完成后,输出一个空行。
Sample
Input
2
5 10
A
P 9
A
P 6
P 3
P 10
P 8
A
P 2
O
2 5
P 1
P 3
O
P 5
A
Output
E
9
8
F
8
3
5
Hint
建议: 用串的方式(%s)读入操作字符。
链栈
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
int len;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
p->len=0;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
p->len--;
free(t);
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
p->len++;
}
int isempty(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clear(stack *p)
{
while(isempty(p))
{
pop(p);
}
p->len=0;
}
int main()
{
int n;
stack *p;
p=creatstack();
scanf("%d",&n);
while(n--)
{
int maxlen,m,num;
char str[100];
scanf("%d %d",&maxlen,&m);
for(int i=0;i<m;i++)
{
scanf("%s",str);
if(str[0]=='P')
{
scanf("%d",&num);
if(p->len==maxlen)
{
printf("F\n");
}
else
{
push(p,num);
}
}
else if(str[0]=='A')
{
if(!isempty(p))
{
printf("E\n");
}
else
{
printf("%d\n",top(p));
}
}
else if(str[0]=='O')
{
if(!isempty(p))
{
printf("E\n");
}
else
{
printf("%d\n",top(p));
pop(p);
}
}
}
printf("\n");
clear(p);
}
return 0;
}
顺序栈
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Stack
{
int *top;
int *base;
int len;
}stack;
stack creatstack()
{
stack p;
p.top=(int *)malloc(10000 * sizeof(int));
p.base=p.top;
p.len=0;
return p;
}
int top(stack p)
{
return *(p.top-1);
}
void pop(stack *p)
{
p->top--;
p->len--;
}
void push(stack *p,int n)
{
*(p->top)=n;
p->top++;
p->len++;
}
int isempty(stack p)
{
if(p.base==p.top)
{
return 0;
}
else
{
return 1;
}
}
void clear(stack *p)
{
while(isempty(*p))
{
pop(p);
}
p->len=0;
}
int main()
{
int n;
stack p;
p=creatstack();
scanf("%d",&n);
while(n--)
{
int maxlen,m,num;
char str[100];
scanf("%d %d",&maxlen,&m);
for(int i=0;i<m;i++)
{
scanf("%s",str);
if(str[0]=='P')
{
scanf("%d",&num);
if(p.len==maxlen)
{
printf("F\n");
}
else
{
push(&p,num);
}
}
else if(str[0]=='A')
{
if(!isempty(p))
{
printf("E\n");
}
else
{
printf("%d\n",top(p));
}
}
else if(str[0]=='O')
{
if(!isempty(p))
{
printf("E\n");
}
else
{
printf("%d\n",top(p));
pop(&p);
}
}
}
printf("\n");
clear(&p);
}
return 0;
}
I - 数据结构实验之栈与队列九:行编辑器
Description
一个简单的行编辑程序的功能是:接受用户从终端输入的程序或数据,并存入用户的数据区。
由于用户在终端上进行输入时,不能保证不出差错,因此,若在编辑程序中,“每接受一个字符即存入用户数据区”的做法显然不是最恰当的。较好的做法是,设立一个输入缓冲区,用以接受用户输入的一行字符,然后逐行存入用户数据区。允许用户输入出差错,并在发现有误时可以及时更正。例如,当用户发现刚刚键入的一个字符是错的时,可补进一个退格符"#",以表示前一个字符无效;
如果发现当前键入的行内差错较多或难以补救,则可以键入一个退行符"@",以表示当前行中的字符均无效。
如果已经在行首继续输入'#'符号无效。
Input
输入多行字符序列,行字符总数(包含退格符和退行符)不大于250。
Output
按照上述说明得到的输出。
Sample
Input
whli##ilr#e(s#*s)
outcha@putchar(*s=#++);
Output
while(*s)
putchar(*s++);
链栈
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node
{
char data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
char top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
}
void push(stack *p,char n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int isempty(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clear(stack *p)
{
while(isempty(p))
{
pop(p);
}
}
void print(node *p)
{
if(p==NULL)
{
return;
}
else
{
print(p->next);
}
if(p)
{
printf("%c",p->data);
}
}
int main()
{
char str[300];
stack *p;
p = creatstack();
while(scanf("%s",str)!=EOF)
{
int n = strlen(str);
for(int i=0;i<n;i++)
{
if(str[i]=='@')
{
clear(p);
}
else if(str[i]=='#')
{
if(isempty(p))
{
pop(p);
}
}
else
{
push(p,str[i]);
}
}
print(p->top->next);
clear(p);
printf("\n");
}
return 0;
}
顺序栈
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char s[300];
int r=0;
typedef struct Stack
{
char *top;
char *base;
int len;
}stack;
stack creatstack()
{
stack p;
p.top=(char *)malloc(10000 * sizeof(int));
p.base=p.top;
p.len=0;
return p;
}
char top(stack p)
{
return *(p.top-1);
}
void pop(stack *p)
{
p->top--;
p->len--;
}
void push(stack *p,char c)
{
*(p->top)=c;
p->top++;
p->len++;
}
int isempty(stack p)
{
if(p.top==p.base)
{
return 0;
}
else
{
return 1;
}
}
void clear(stack *p)
{
while(isempty(*p))
{
pop(p);
}
}
void print(stack *p)
{
while(p->top!=p->base)
{
s[r++]=top(*p);
pop(p);
}
for(int i=r-1;i>=0;i--)
{
printf("%c",s[i]);
}
r=0;
printf("\n");
}
int main()
{
char str[300];
stack p;
p = creatstack();
while(scanf("%s",str)!=EOF)
{
int n = strlen(str);
for(int i=0;i<n;i++)
{
if(str[i]=='@')
{
clear(&p);
}
else if(str[i]=='#')
{
if(isempty(p))
{
pop(&p);
}
}
else
{
push(&p,str[i]);
}
}
print(&p);
clear(&p);
memset(s,0,sizeof(s));
memset(str,0,sizeof(str));
}
return 0;
}
J - 数据结构实验之栈与队列十:走迷宫
Description
一个由n * m 个格子组成的迷宫,起点是(1, 1), 终点是(n, m),每次可以向上下左右四个方向任意走一步,并且有些格子是不能走动,求从起点到终点经过每个格子至多一次的走法数。
Input
第一行一个整数T 表示有T 组测试数据。(T <= 110)
对于每组测试数据:
第一行两个整数n, m,表示迷宫有n * m 个格子。(1 <= n, m <= 6, (n, m) !=(1, 1) ) 接下来n 行,每行m 个数。其中第i 行第j 个数是0 表示第i 行第j 个格子可以走,否则是1 表示这个格子不能走,输入保证起点和终点都是都是可以走的。
任意两组测试数据间用一个空行分开。
Output
对于每组测试数据,输出一个整数R,表示有R 种走法。
Sample
Input
3
2 2
0 1
0 0
2 2
0 1
1 0
2 3
0 0 0
0 0 0
Output
1
0
4
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int path[110][110];
int sign[110][110];
int ways;
int n,m;
void DFS(int x,int y)
{
if(x<1 || y<1 || x>n || y>m || path[x][y]==1)
{
return;
}
if(x==n && y==m)
{
ways++;
return;
}
if(sign[x][y]==0)
{
sign[x][y]=1;
DFS(x+1,y);
DFS(x,y+1);
DFS(x-1,y);
DFS(x,y-1);
sign[x][y]=0;
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
scanf("%d",&path[i][j]);
}
}
ways=0;
DFS(1,1);
printf("%d\n",ways);
memset(path,0,sizeof(path));
memset(sign,0,sizeof(sign));
}
}
数据结构实验之栈与队列十一:refresh的停车场
Description
refresh最近发了一笔横财,开了一家停车场。由于土地有限,停车场内停车数量有限,但是要求进停车场的车辆过多。当停车场满时,要进入的车辆会进入便道等待,最先进入便道的车辆会优先
进入停车场,而且停车场的结构要求只出去的车辆必须是停车场中最后进去的车辆。现告诉你停车场容量N以及命令数M,以及一些命令(Add num 表示车牌号为num的车辆要进入停车场或便道,
Del 表示停车场中出去了一辆车,Out 表示便道最前面的车辆不再等待,放弃进入停车场)。假设便道内的车辆不超过1000000.
Input
输入为多组数据,每组数据首先输入N和M(0< n,m <200000),接下来输入M条命令。
Output
输入结束后,如果出现停车场内无车辆而出现Del或者便道内无车辆而出现Out,则输出Error,否则输出停车场内的车辆,最后进入的最先输出,无车辆不输出。
Sample
Input
2 6
Add 18353364208
Add 18353365550
Add 18353365558
Add 18353365559
Del
Out
Output
18353365558
18353364208
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
char str[50];
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
int len;
}stack;
typedef struct Queue
{
node *front;
node *rear;
int len;
}queue;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
p->len=0;
return p;
}
void popstack(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
p->len--;
free(t);
}
void pushstack(stack *p,char s[])
{
node *t;
t=creatnode();
strcpy(t->str,s);
t->next=p->top->next;
p->top->next=t;
p->base=t;
p->len++;
}
int emptystack(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clearstack(stack *p)
{
while(emptystack(p))
{
popstack(p);
}
}
queue *creatqueue()
{
queue *p;
p=(queue *)malloc(sizeof(queue));
p->front=creatnode();
p->rear=p->front;
p->len=0;
return p;
}
void popqueue(queue *p)
{
node *t;
t=p->front->next;
p->front->next=p->front->next->next;
p->len--;
free(t);
}
void pushqueue(queue *p,char s[])
{
node *t;
t=creatnode();
strcpy(t->str,s);
t->next=p->rear->next;
p->rear->next=t;
p->rear=t;
p->len++;
}
int emptyqueue(queue *p)
{
if(p->front->next)
{
return 1;
}
else
{
return 0;
}
}
void clearqueue(queue *p)
{
while(emptyqueue(p))
{
popqueue(p);
}
}
void print(node *p)
{
while(p->next)
{
printf("%s\n",p->next->str);
p->next=p->next->next;
}
}
int main()
{
int maxnum,num;
char s[10],s1[100];
stack *p1;
queue *p2;
p1=creatstack();
p2=creatqueue();
while(scanf("%d%d",&maxnum,&num)!=EOF)
{
clearstack(p1);
clearqueue(p2);
int flag=1;
while(num--)
{
scanf("%s",s);
if(strcmp(s,"Add")==0)
{
scanf("%s",s1);
if(p1->len<maxnum)
{
pushstack(p1,s1);
}
else
{
pushqueue(p2,s1);
}
}
else if(strcmp(s,"Del")==0)
{
if(!emptystack(p1))
{
flag=0;
}
else
{
popstack(p1);
if(emptyqueue(p2))
{
strcpy(s1,p2->front->next->str);
popqueue(p2);
pushstack(p1,s1);
}
}
}
else if(strcmp(s,"Out")==0)
{
if(!emptyqueue(p2))
{
flag=0;
}
else
{
popqueue(p2);
}
}
}
if(!flag)
{
printf("Error\n");
}
else
{
print(p1->top);
}
}
}
L - Special Judge Ⅲ(就是和上面栈的出序列操作判断题目几乎一样)
Description
Q:什么是 Special Judge,Special Judge 的题目有什么不同?
A:一个题目可以接受多种正确方案,即有多组解的时候,题目就必须被 Special Judge。Special Judge 程序使用输入数据和一些其他信息来判答你程序的输出,并将判答结果返回。
不抽黑贞与咸鱼有什么区别?
5月3日 FGO(Fate/Grand Order) 赝作活动来袭,MLE 开始了他的玄学抽卡:
他在 n 个小方块上写上数字,并按照先后顺序往上堆,在堆的过程中他会随机性的把上面的小方块抽走,堆完以后再依次从上往下把剩余没抽完的小方块抽走。按照小方块抽走的先后顺序排列开来(先拿走的小方块放最前面),之后再随机选择一个小方块,这个小方块上面的数字就表示活动开始以后的若干秒后开始抽卡。
不幸的是由于过于激动把小方块抽走的先后顺序给忘了,MLE 向闲来无事的 keke 求助,让他给出一个序列看自己能不能想起来,但为了避免浪费时间,MLE 希望 keke 给出的序列符合小方块抽走后排列的顺序,现在问题留给你,由你来判断这个序列是否合法。
Input
输入数据有多组(数据组数不超过 1000),到 EOF 结束。
对于每组数据:
- 第一行先输入一个数 n (0 <= n <= 1000) 表示小方块的个数
- 第二行输入 n 个数表示小方块上的数字,均为正整数
- 第三行输入 keke 给出的序列,长度与小方块个数一致
所有数据范围均为 [0, 1000]。
Output
Keke 的答案正确输出 "Accepted",否则输出 "Wrong Answer"(不包括引号)。
Sample
Input
5
1 2 3 4 5
5 4 3 2 1
Output
Accepted
Hint
当 n 为 0 时认为是 "Accepted"。
链栈
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
int len;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
p->len=0;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int emptystack(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clearstack(stack *p)
{
while(emptystack(p))
{
pop(p);
}
}
int main()
{
int n;
stack *p;
p=creatstack();
while(scanf("%d",&n)!=EOF)
{
int s1[1001],s2[1001];
for(int i=0;i<n;i++)
{
scanf("%d",&s1[i]);
}
for(int i=0;i<n;i++)
{
scanf("%d",&s2[i]);
}
int i,j;
i=j=0;
while(j<n)
{
if(i<n && s1[i]==s2[j])
{
i++;
j++;
}
else
{
if(emptystack(p) && s2[j]==top(p))
{
j++;
pop(p);
}
else if(i<n)
{
push(p,s1[i]);
i++;
}
else
{
break;
}
}
}
if(n==0 || !emptystack(p))
{
printf("Accepted\n");
}
else
{
printf("Wrong Answer\n");
}
}
return 0;
}
M - 我成了瘸腿鹅
Description
智 (hei) 慧 (bang) 长 (yi) 者 (ge) 阿福虽说是智勇双全,却无奈老是被该 (zheng) 死 (yi) 的成龙欺负。既然武斗不行,那么今天阿福决定靠他的智慧为自己找回些面子。所以他今天打算和成龙来比纸牌接龙游戏,输的人将会接受惩罚。游戏是这样的阿福先出牌,然后成龙出牌,出的牌按出牌顺序排成一列,如果当前出的牌在出牌序列中,那么那个人可以取走两张相同牌之间的所有牌并加上相应于牌数的分。比如原牌的排列为 5 4 3 6 9 8 现在成龙出牌 9 那么他可以取走 9 8 9 得到 3 分,然后牌的序列就变成 5 4 3 6 了。
最后看他们两个人的得分谁比较高,分数低的人将会接受惩罚,由于阿福长的比较丑,所以得分相同的情况下算阿福输(长得丑怪我咯)。
智 (hei) 慧 (bang) 长 (yi) 者 (ge) 阿福相信自己智勇双全一定会赢的,所以他打算赌得大一点:”谁输了就把他打成瘸腿鹅!”。由于没有人见证了他们的比赛过程,只知道他们的总出牌序列,想在好奇得到 UMR 想知道最后谁成了瘸腿鹅,但是 UMR 智商令人着急所以只能聪明的你求助了,你能告诉他谁被打成瘸腿鹅了吗?如果你说对了 UMR 将会将给你一个大大的 AC 作为回报。
Input
第一行输入一个 nn,代表总共出了 nn 张牌 (2 \leqslant n \leqslant 100000)(2⩽n⩽100000)。
接下来 nn 个数 a_{i}ai,代表他们出的牌 (1 \leqslant a_{i} \leqslant 10)(1⩽ai⩽10)。
Output
如果阿福输了输出 ON!
。
否则输出 HaHa!
(不存在的)。
Sample
Input
9
1 2 5 8 7 1 8 7 8
Output
ON!
Hint
阿福先出牌。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
int len;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
p->len--;
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int emptystack(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
int main()
{
int n;
int num1,num2,num;
int s[100001],a[10]={0};
stack *p;
scanf("%d",&n);
p=creatstack();
num1=num2=0;
for(int i=1;i<=n;i++)
{
num=0;
scanf("%d",&s[i]);
a[s[i]]++;
if(a[s[i]]==1)
{
push(p,s[i]);
}
else if(a[s[i]]==2)
{
while(emptystack(p) && top(p)!=s[i])
{
a[top(p)]=0;
pop(p);
num++;
}
pop(p);
num+=2;
a[s[i]]=0;
if(i%2==0)
{
num1+=num;
}
else
{
num2+=num;
}
}
}
if(num1>num2 || num1==num2)
{
printf("ON!");
}
else
{
printf("HaHa!");
}
return 0;
}
N - 蚂蚁花呗
Description
众所周知,蚂蚁是一种十分神奇的生物,在算法设计中,我们往往能从它身上得到启发,例如在求解TSP问题中,就有一种模仿蚂蚁行为方式而设计出的蚁群算法。 z这种算法是由Marco Dorigo等人在1991年研究新型算法的过程中,发现蚁群在寻找食物时,通过蚂蚁分泌一种称为信息素的生物激素交流觅食信息从而能快速的找到目标,据此提出来的一种十分神奇的算法。
今天,我们也来从蚂蚁身上寻找一些灵感。
水平线上有 N 只蚂蚁,每只蚂蚁的位置及大小均不同。他们沿着 X 轴爬行,有的向左,有的向右,爬行的速度是一样的,两只蚂蚁相遇大一点的会吃掉小的。
现在从左到右给出每只蚂蚁的大小和爬行的方向(0 表示向左,1 表示向右)。问足够长的时间之后,能剩下多少只蚂蚁?
Input
首先输入测试数据的组数t,后面是t组测试数据。
对于每组测试数据:
第 1 行:一个整数 N,表示蚂蚁的数量 (1≤N≤100000)。
第 2 到 N+1 行:每行两个数 Ai,Bi (1≤Ai≤1e9,Bi∈{0,1}),中间用空格分隔,分别表示蚂蚁的大小及爬 行的方向,Bi=0 表示向左,Bi=1 表示向右。
Output
输出最终剩下的蚂蚁的数量。
Sample
Input
1
5
4 0
3 1
2 0
1 0
5 0
Output
2
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define ll long long
const int N = 1e5;
typedef struct Node
{
int data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
int len;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
return p;
}
int top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
free(t);
p->len--;
}
void push(stack *p,int n)
{
node *t;
t=creatnode();
t->data=n;
t->next=p->top->next;
p->top->next=t;
p->base=t;
}
int emptystack(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clearstack(stack *p)
{
while(emptystack(p))
{
pop(p);
}
}
int main()
{
int T,num,n;
stack *p;
p=creatstack();
scanf("%d",&T);
while(T--)
{
num = 0;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
int size,dir;
scanf("%d%d",&size,&dir);
if(!dir)
{
while(emptystack(p) && top(p)<size)
{
num++;
pop(p);
}
if(emptystack(p))
{
num++;
}
}
else
{
push(p,size);
}
}
printf("%d\n",n-num);
clearstack(p);
}
return 0;
}
算术表达式的转换
Description
小明在学习了数据结构之后,突然想起了以前没有解决的算术表达式转化成后缀式的问题,今天他想解决一下。
因为有了数据结构的基础小明很快就解出了这个问题,但是他突然想到怎么求出算术表达式的前缀式和中缀式呢?小明很困惑。聪明的你帮他解决吧。
Input
输入一算术表达式,以\'#\'字符作为结束标志。(数据保证无空格,只有一组输入)
Output
输出该表达式转换所得到的前缀式 中缀式 后缀式。分三行输出,顺序是前缀式 中缀式 后缀式。
Sample
Input
a*b+(c-d/e)*f#
Output
+*ab*-c/def a*b+c-d/e*f ab*cde/-f*+
Hint
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node
{
char data;
Node *next;
}node;
typedef struct Stack
{
node *top;
node *base;
int len;
}stack;
node *creatnode()
{
node *p;
p=(node *)malloc(sizeof(node));
p->next=NULL;
return p;
}
stack *creatstack()
{
stack *p;
p=(stack *)malloc(sizeof(stack));
p->top=creatnode();
p->base=p->top;
p->len=0;
return p;
}
char top(stack *p)
{
return p->top->next->data;
}
void pop(stack *p)
{
node *t;
t=p->top->next;
p->top->next=p->top->next->next;
p->len--;
free(t);
}
void push(stack *p,char c)
{
node *t;
t=creatnode();
t->data=c;
t->next=p->top->next;
p->top->next=t;
p->base=t;
p->len++;
}
int emptystack(stack *p)
{
if(p->top->next)
{
return 1;
}
else
{
return 0;
}
}
void clearstack(stack *p)
{
while(emptystack(p))
{
pop(p);
}
}
void print(node *p)
{
while(p)
{
printf("%c",p->data);
p=p->next;
}
printf("\n");
}
int main()
{
char str[10001];
stack *p1,*p2;
scanf("%s",str);
p1=creatstack();
p2=creatstack();
for(int i=strlen(str)-2;i>=0;i--)
{
if(str[i]>='a' && str[i]<='z')
{
push(p1,str[i]);
}
else if(str[i]=='+' || str[i]=='-')
{
if(!emptystack(p2) || top(p2)==')')
{
push(p2,str[i]);
}
else if(top(p2)=='*' || top(p2)=='/')
{
while(top(p2)=='*' || top(p2)=='/')
{
push(p1,top(p2));
pop(p2);
push(p2,str[i]);
}
}
else
{
push(p2,str[i]);
}
}
else if(str[i]=='*' || str[i]=='/' || str[i]==')')
{
push(p2,str[i]);
}
else if(str[i]=='(')
{
while(top(p2)!=')')
{
push(p1,top(p2));
pop(p2);
}
pop(p2);
}
}
while(emptystack(p2))
{
push(p1,top(p2));
pop(p2);
}
print(p1->top->next);
clearstack(p1);
for(int i=0;str[i]!='#';i++)
{
if(str[i]!='(' && str[i]!=')')
{
printf("%c",str[i]);
}
}
printf("\n");
for(int i=0;str[i]!='#';i++)
{
if(str[i]>='a' && str[i]<='z')
{
push(p2,str[i]);
}
else if(str[i]=='(')
{
push(p1,str[i]);
}
else if(str[i]==')')
{
while(top(p1)!='(')
{
push(p2,top(p1));
pop(p1);
}
pop(p1);
}
else if(str[i]=='*' || str[i]=='/')
{
if(!emptystack(p1) || top(p1)=='(' || top(p1)=='+' || top(p1)=='-')
{
push(p1,str[i]);
}
else
{
push(p2,top(p1));
pop(p1);
push(p1,str[i]);
}
}
else if(str[i]=='+' || str[i]=='-')
{
if(!emptystack(p1) || top(p1)=='(')
{
push(p1,str[i]);
}
else
{
push(p2,top(p1));
pop(p1);
push(p1,str[i]);
}
}
}
while(emptystack(p2))
{
push(p1,top(p2));
pop(p2);
}
print(p1->top->next);
return 0;
}
M - 双向队列
Description
想想双向链表……双向队列的定义差不多,也就是说一个队列的队尾同时也是队首;两头都可以做出队,入队的操作。
现在给你一系列的操作,请输出最后队列的状态;
命令格式:
LIN X X表示一个整数,命令代表左边进队操作;
RIN X 表示右边进队操作;
ROUT
LOUT 表示出队操作;
Input
第一行包含一个整数M(M<=10000),表示有M个操作;
以下M行每行包含一条命令;
命令可能不合法,对于不合法的命令,请在输出中处理;
Output
输出的第一行包含队列进行了M次操作后的状态,从左往右输出,每两个之间用空格隔开;
以下若干行处理不合法的命令(如果存在);
对于不合法的命令,请输出一行X ERROR
其中X表示是第几条命令;
Sample
Input
8 LIN 5 RIN 6 LIN 3 LOUT ROUT ROUT ROUT LIN 3
Output
3 7 ERROR
Hint
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int type;
typedef struct node
{
type data;
struct node *next;
}node,*nodeptr;
typedef struct
{
nodeptr fron;
nodeptr rear;
int length;
}linkq;
int creat(linkq &Q)
{
Q.fron=Q.rear=(nodeptr)malloc(sizeof(node));
if(!Q.fron) exit(0);
Q.fron->next=NULL;
Q.rear=Q.fron;
Q.length=0;
return 1;
}
int lenter(linkq &Q,type e)
{
nodeptr m;
nodeptr p=(nodeptr)malloc(sizeof(node));
if(!p) exit(0);
p->data=e;
p->next=Q.fron->next;
Q.fron->next=p;
m=Q.fron;
while(m->next!=NULL)
m=m->next;
Q.rear=m;
Q.length++;
return 1;
}
int renter(linkq &Q,type e)
{
nodeptr p=(nodeptr)malloc(sizeof(node));
if(!p) exit(0);
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
Q.length++;
return 1;
}
int lleave(linkq &Q,type &e)
{
if(Q.length==0) return 0;
nodeptr p;
p=Q.fron->next;
e=p->data;
Q.fron->next=p->next;
if(Q.rear==p) Q.rear=Q.fron;
free(p);
Q.length--;
return 1;
}
int rleave(linkq &Q,type &e)
{
if(Q.length==0) return 0;
nodeptr p,b;
p=Q.rear;
e=p->data;
b=Q.fron;
while(b->next!=Q.rear)
b=b->next;
b->next=NULL;
Q.rear=b;
free(p);
Q.length--;
return 1;
}
int main()
{
linkq Q;
nodeptr q;
creat(Q);
int i,n,key,k=0;
int wrong[10000]={0};
char order[10];
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%s",order);
if(strcmp(order,"LIN")==0)
{
scanf("%d",&key);
lenter(Q,key);
}
else if(strcmp(order,"RIN")==0)
{
scanf("%d",&key);
renter(Q,key);
}
else if(strcmp(order,"LOUT")==0)
{
if(Q.fron==Q.rear)
wrong[k++]=i;
else
lleave(Q,key);
}
else if(strcmp(order,"ROUT")==0)
{
if(Q.fron==Q.rear)
wrong[k++]=i;
else
rleave(Q,key);
}
}
q=Q.fron->next;
while(q)
{
printf("%d",q->data);
q=q->next;
if(q)
printf(" ");
else
printf("\n");
}
for(i=0;i<k;i++)
printf("%d ERROR\n",wrong[i]);
return 0;
}