栈是一种很神奇的数据结构，具有先进后出的特性。现在有如下操作。
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;
}
// 取栈顶元素赋值到e。成功返回OK，否则返回ERROR
Status top(SqStack S, ElemType &e);
// e入栈。 成功返回OK，否则返回ERROR
Status push(SqStack &S, ElemType e);
// 出栈。成功返回OK，否则返回ERROR
Status pop(SqStack &S);
int main(){
int cmd, e, re;
SqStack S;
init(S);
while(~scanf("%d",&cmd)){
switch(cmd){
case 1: // get top
re = top(S, e);
if(re) printf("%d\n", e);
else printf("ERROR\n");
break;
case 2: // push
scanf("%d", &e);
re = push(S,e);
if(re) printf("OK\n");
else printf("ERROR\n");
break;
case 3: // pop
re = pop(S);
if(re) printf("OK\n");
else printf("ERROR\n");
break;
default:
printf("Unknown Command\n");
break;
}
}
}
/
// 取栈顶元素赋值到e。成功返回OK，否则返回ERROR
Status top(SqStack S, ElemType &e){
if(S.top==-1)
return ERROR;
e=S.elem[S.top];
return OK;
}
// e入栈。 成功返回OK，否则返回ERROR
Status push(SqStack &S, ElemType e){
if(S.top==MAXSIZE-1)
return ERROR;
S.elem[++S.top]=e;
return OK;
}
// 出栈。成功返回OK，否则返回ERROR
Status pop(SqStack &S){
if(S.top==-1)
return ERROR;
--S.top;
return OK;
}
栈是一种很神奇的数据结构，具有先进后出的特性。
现在有如下操作。
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);
// 将e入栈。返回OK
Status push(LinkStack &S, ElemType e);
// 出栈。操作成功返回OK，否则返回ERROR
Status pop(LinkStack &S);
// 将栈顶元素赋值给e。操作成功返回OK，否则返回ERROR
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;
}
// 将e入栈。返回OK
Status push(LinkStack &S, ElemType e){
SNode *tmp=new SNode;
tmp->data=e;
tmp->next=S->next;
S->next=tmp;
return OK;
}
// 出栈。操作成功返回OK，否则返回ERROR
Status pop(LinkStack &S){
if(S->next==NULL)
return ERROR;
SNode *tmp=S->next;
S->next=tmp->next;
delete tmp;
return OK;
}
// 将栈顶元素赋值给e。操作成功返回OK，否则返回ERROR
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;
}
当程序中同时使用两个栈时，可以将两个栈的栈底设在向量空间（数组）的两端，让两个栈各自向中间延伸。如下图所示：
当一个栈的元素较多，超过向量空间的一半时，只要另一个栈的元素不多，那么前者就可以占用后者的部分存储空间。
只有当整个向量空间被两个栈占满（即两个栈顶相遇）时，入栈操作才会发生上溢，因此两个栈共享一个长度为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;
}
// 将第i个栈的栈顶元素赋值给e
Status top(DStack S, int i, int &e);
// 第i个栈入栈e。
Status push(DStack &S, int i, int e);
// 第i个栈出栈。
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;
}
}
}
/
// 将第i个栈的栈顶元素赋值给e
Status top(DStack S, int i, int &e){
// if((S.top1+1)==S.top2) return ERROR;
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;
}
}
// return OK;
}
// 第i个栈入栈e。
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;
}
}
// return OK;
}
// 第i个栈出栈。
Status pop(DStack &S, int i){
// if((S.top1+1)==S.top2) return ERROR;
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;
}
}
// return OK;
}
从图中可以看出，这个火车站的进/出站操作符合先进后出的原则。
已知火车出站和进站顺序，判断该进站和出站顺序是否合理。
输入要求：
多组输入，每组输入一行。
每行首先输入一个数字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;
}