0701
栈是一种很神奇的数据结构,具有先进后出的特性。现在有如下操作。
1:取栈顶元素
2:入栈
3:出栈
请给出缺失的函数(用顺序栈实现)。
输入要求:
多组输入
每组输入一个整数cmd,代表操作命令,如果是入栈操作,再输入一个需要入栈的整数。
输出要求:
根据输入输出操作结果,详见代码
数据示例1:
输入:
1
2 1
2 2
2 3
2 4
2 5
2 6
1
3
1
2 6
1
3
3
3
3
3
3
输出:
ERROR
OK
OK
OK
OK
OK
ERROR
5
OK
4
OK
6
OK
OK
OK
OK
OK
ERROR
# include <stdio.h>
# include <stdlib.h>
# define MAXSIZE 5
typedef int Status;
# define OK 1
# define ERROR 0
typedef int ElemType;
typedef struct {
ElemType * elem;
int top;
} SqStack;
Status init ( SqStack & S) {
S. elem = new ElemType[ MAXSIZE] ;
S. top = - 1 ;
}
Status top ( SqStack S, ElemType & e) ;
Status push ( SqStack & S, ElemType e) ;
Status pop ( SqStack & S) ;
int main ( ) {
int cmd, e, re;
SqStack S;
init ( S) ;
while ( ~ scanf ( "%d" , & cmd) ) {
switch ( cmd) {
case 1 :
re = top ( S, e) ;
if ( re) printf ( "%d\n" , e) ;
else printf ( "ERROR\n" ) ;
break ;
case 2 :
scanf ( "%d" , & e) ;
re = push ( S, e) ;
if ( re) printf ( "OK\n" ) ;
else printf ( "ERROR\n" ) ;
break ;
case 3 :
re = pop ( S) ;
if ( re) printf ( "OK\n" ) ;
else printf ( "ERROR\n" ) ;
break ;
default :
printf ( "Unknown Command\n" ) ;
break ;
}
}
}
Status top ( SqStack S, ElemType & e) {
if ( S. top== - 1 )
return ERROR;
e= S. elem[ S. top] ;
return OK;
}
Status push ( SqStack & S, ElemType e) {
if ( S. top== MAXSIZE- 1 )
return ERROR;
S. elem[ ++ S. top] = e;
return OK;
}
Status pop ( SqStack & S) {
if ( S. top== - 1 )
return ERROR;
-- S. top;
return OK;
}
0702
栈是一种很神奇的数据结构,具有先进后出的特性。
现在有如下操作。
1:入栈
2:出栈,如果栈为空则输出empty
3:清空栈
4:取栈顶元素,如果成功则输出栈顶元素,否则输出empty
请给出缺失的函数(用链栈实现)。
输入要求:
依次输入操作代码cmd,对于操作1,后面跟一个数,表示要推入栈的元素
对于操作2,3,4,直接进行操作即可
输出要求:
详见代码及样例输出
数据示例1:
输入:
1 10
1 20
1 30
1 40
1 50
1 60
1 70
1 80
1 90
1 100
1 11
4
2
2
4
1 111
4
3
2
4
输出:
11
90
111
empty
empty
思路提示:
不允许使用C++中的stack类
# include <stdio.h>
# include <stdlib.h>
typedef int Status;
# define OK 1
# define ERROR 0
# define OVERFLOW - 2
typedef int ElemType;
typedef struct SNode {
ElemType data;
struct SNode * next;
} SNode, * LinkStack;
void init ( LinkStack & S) ;
Status push ( LinkStack & S, ElemType e) ;
Status pop ( LinkStack & S) ;
Status getTop ( LinkStack S, ElemType & e) ;
void clear ( LinkStack & S) ;
int main ( ) {
int cmd, x;
LinkStack S;
init ( S) ;
while ( ~ scanf ( "%d" , & cmd) ) {
switch ( cmd) {
case 1 :
scanf ( "%d" , & x) ;
if ( ! push ( S, x) ) printf ( "full\n" ) ;
break ;
case 2 :
if ( ! pop ( S) ) printf ( "empty\n" ) ;
break ;
case 3 :
clear ( S) ;
break ;
case 4 :
if ( getTop ( S, x) ) printf ( "%d\n" , x) ;
else printf ( "empty\n" ) ;
break ;
default :
printf ( "Unknown Command\n" ) ;
break ;
}
}
}
void init ( LinkStack & S) {
S= new SNode;
S-> next= NULL ;
}
Status push ( LinkStack & S, ElemType e) {
SNode * tmp= new SNode;
tmp-> data= e;
tmp-> next= S-> next;
S-> next= tmp;
return OK;
}
Status pop ( LinkStack & S) {
if ( S-> next== NULL )
return ERROR;
SNode * tmp= S-> next;
S-> next= tmp-> next;
delete tmp;
return OK;
}
Status getTop ( LinkStack S, ElemType & e) {
if ( S-> next== NULL )
return ERROR;
e= S-> next-> data;
return OK;
}
void clear ( LinkStack & S) {
S-> next= NULL ;
}
0703
当程序中同时使用两个栈时,可以将两个栈的栈底设在向量空间(数组)的两端,让两个栈各自向中间延伸。如下图所示:
当一个栈的元素较多,超过向量空间的一半时,只要另一个栈的元素不多,那么前者就可以占用后者的部分存储空间。
只有当整个向量空间被两个栈占满(即两个栈顶相遇)时,入栈操作才会发生上溢,因此两个栈共享一个长度为M的向量空间可以在
一定程度上避免内存空间浪费。
输入要求:
多组输入。
每组数据首先输入一个代表操作的整数cmd。
cmd==1表示取栈顶元素;
cmd==2表示入栈操作;
cmd==3表示出栈操作。
接着输入栈的编号,1代表对栈1(低端)进行操作,2代表对栈2进行操作。
如果是入栈操作(cmd==2),需要再输入一个要入栈的元素(整数)
输出要求:
cmd==1时,如果取栈顶操作成功(栈不为空)输出栈顶元素的值,否则输出ERROR;
cmd==2时,如果入栈操作成功(栈不满)输出OK,否则输出ERROR;
cmd==3时,如果出栈操作成功(栈不为空)输出OK,否则输出ERROR。
数据示例1:
输入:
1 1
2 1 1
2 1 3
2 1 5
2 2 2
2 2 4
2 2 6
1 1
1 2
3 1
3 1
3 1
3 1
3 2
3 2
3 2
输出:
ERROR
OK
OK
OK
OK
OK
ERROR
5
4
OK
OK
OK
ERROR
OK
OK
ERROR
# include <stdio.h>
# include <stdlib.h>
# define MAXSIZE 5
typedef int Status;
# define OK 1
# define ERROR 0
typedef struct {
int * elem;
int top1, top2;
} DStack;
void init ( DStack & S) {
S. elem = new int [ MAXSIZE] ;
S. top1 = - 1 ;
S. top2 = MAXSIZE;
}
Status top ( DStack S, int i, int & e) ;
Status push ( DStack & S, int i, int e) ;
Status pop ( DStack & S, int i) ;
int main ( ) {
int cmd, i, re;
int e;
DStack S;
init ( S) ;
while ( ~ scanf ( "%d" , & cmd) ) {
scanf ( "%d" , & i) ;
switch ( cmd) {
case 1 :
re = top ( S, i, e) ;
if ( re) printf ( "%d\n" , e) ;
else printf ( "ERROR\n" ) ;
break ;
case 2 :
scanf ( "%d" , & e) ;
re = push ( S, i, e) ;
if ( re) printf ( "OK\n" ) ;
else printf ( "ERROR\n" ) ;
break ;
case 3 :
re = pop ( S, i) ;
if ( re) printf ( "OK\n" ) ;
else printf ( "ERROR\n" ) ;
break ;
}
}
}
Status top ( DStack S, int i, int & e) {
if ( i== 1 ) {
if ( S. top1> - 1 ) {
e= S. elem[ S. top1] ;
return OK;
} else {
return ERROR;
}
}
else {
if ( S. top2< MAXSIZE) {
e= S. elem[ S. top2] ;
return OK;
} else {
return ERROR;
}
}
}
Status push ( DStack & S, int i, int e) {
if ( ( S. top1+ 1 ) == S. top2) return ERROR;
if ( i== 1 ) {
if ( S. top1< MAXSIZE&& S. top1< S. top2) {
S. top1++ ;
S. elem[ S. top1] = e;
return OK;
} else {
return ERROR;
}
}
else {
if ( S. top2- 1 > S. top1) {
S. top2-- ;
S. elem[ S. top2] = e;
return OK;
} else {
return ERROR;
}
}
}
Status pop ( DStack & S, int i) {
if ( i== 1 ) {
if ( S. top1> - 1 ) {
S. top1-- ;
return OK;
} else {
return ERROR;
}
}
else {
if ( S. top2< MAXSIZE) {
S. top2++ ;
return OK;
} else {
return ERROR;
}
}
}
0704
从图中可以看出,这个火车站的进/出站操作符合先进后出的原则。
已知火车出站和进站顺序,判断该进站和出站顺序是否合理。
输入要求:
多组输入,每组输入一行。
每行首先输入一个数字n(0<n<10),表示有n辆火车,编号为1-n。接下来给出两组,每组n个数字,表示进站,出站的顺序。
输出要求:
对于每组输入,如果火车的进站和出站顺序合理,打印"Yes."并换行,否则打印"No."并换行。
数据示例1:
输入:
3 123 321
3 123 312
3 123 213
输出:
Yes.
No.
Yes.
思路提示:
第一组数据123 321 的进/出站顺序是合理的,1进2进3进3出2出1出;第二组数据 123 312 是不合理的,1进2进3进3出,然后1出不来啊。
挺简单吧?那你就又要被坑了。我给一组神秘数据:
3 123 213
这个是可以的,如果你程序过不了这个就快点改吧。
# include <cstdio>
# include <cstring>
# include <cmath>
# include <iostream>
# include <algorithm>
# include <queue>
# include <stack>
using namespace std;
char a[ 100000 ] , b[ 100000 ] ;
int p[ 200000 ] ;
stack< char > s;
int main ( ) {
int cut= 0 ;
int n;
while ( ~ scanf ( "%d %s %s" , & n, a, b) ) {
cut++ ;
memset ( p, 0 , sizeof ( p) ) ;
int sum= 0 ;
int len1= strlen ( a) ;
int len2= strlen ( b) ;
int flag= 0 ;
for ( int i= 0 ; i< len1; i++ ) {
s. push ( a[ i] ) ;
p[ sum] = 0 ;
sum++ ;
while ( ! s. empty ( ) && s. top ( ) == b[ flag] && flag< len2) {
flag++ ;
s. pop ( ) ;
p[ sum] = 1 ;
sum++ ;
}
}
if ( flag!= len2) printf ( "No.\n" ) ;
else {
printf ( "Yes.\n" ) ;
}
}
return 0 ;
}