编程题实训-栈

Ayrsheisen

已于 2024-01-15 21:22:02 修改

阅读量1.8k

点赞数 25

分类专栏： educoder 数据结构（实验）文章标签：数据结构 c++

于 2024-01-15 21:07:45 首次发布

本文链接：https://blog.csdn.net/Ayrsheisen/article/details/135611060

版权

educoder 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

数据结构（实验）

9 篇文章 1 订阅

订阅专栏

第2关：双栈的基本操作

任务描述
本关任务：将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空；当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见下图）。试编写双栈初始化，判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为：进栈、栈满的判断、出栈、栈空的判断。

双栈数据结构的定义如下：

typedef struct

{

int top[2], bot[2]; //栈顶和栈底指针

SElemType *V; //栈数组

int m; //栈最大可容纳元素个数

}DblStack;

编程要求
输入
多组数据，每组数据有四行，每行的数据之间均用空格分隔。第一行为一个整数m，
表示数组V的大小，第二行为四个整数e0、e1、d0、d1，e0和e1分别代表压入0号栈和1号栈的整数序列E0和
E1的长度（依次连续入栈，中间没有出栈的情况），d0和d1分别代表从0号栈和1号栈弹出的序列的长度（依次连续出栈，中间没有入栈的情况）。
第三行和第四行分别表示序列E0和E1。当m=0时，输入结束。

输出
对于每组数据输出三行。第一行代表进栈操作完成时栈是否为满（出栈操作尚未执行），栈满输出1，栈不满输出0。
第二行和第三行的数据分别对应0号栈和1号栈。第二行包括d0+1个整数，其中前d0个整数代表出栈序列D0，
最后一个整数代表出栈操作完成时0号栈是否为空，栈空输出0，不空输出1。
第三行包括d1+1个整数，其中前d1个整数代表出栈序列D1，最后一个整数代表出栈操作完成时1号栈是否为空，栈空输出0，不空输出1。整数之间用空格分隔。

测试说明
平台会对你编写的代码进行测试：

测试输入：
7
3 4 2 2
1 2 3
2 3 4 5
12
4 6 4 3
1 3 4 5
1 3 5 6 8 1
0

预期输出：
1
3 2 1
5 4 1
0
5 4 3 1 0
1 8 6 1

#include<iostream>
using namespace std;
typedef struct
{
	int top[2],bot[2];//栈顶和栈底指针
	int *V;//栈数组
	int m;//栈最大可容纳元素个数
}DblStack;
void InitDblStack(DblStack &S,int m)
{//初始化一个大小为m的双向栈
	S.V=new int[m];            //动态分配一个最大容量为m的数组空间
	S.bot[0]=-1;               //左栈栈底指针
	S.bot[1]=m;                //右栈栈底指针
	S.top[0]=-1;               //左栈栈顶指针
	S.top[1]=m;               //右栈栈顶指针
}
int IsEmpty(DblStack S,int i)
{//判断指定的i号栈是否为空，空返回1，否则返回0
	return S.top[i]==S.bot[i];
}
int IsFull(DblStack S)
{//判断栈是否满，满则返回1，否则返回0
	if(S.top[0]+1==S.top[1]) return 1;
	else return 0;
}
void Push(DblStack &S,int i)
{//向指定的i号栈中插入元素x，先移动指针再入栈
	/**************begin************/
if(!IsFull(S)) {           
        if(i == 0) {           
            ++S.top[0];
            cin >> S.V[S.top[0]];
        } else {               
            --S.top[1];
            cin >> S.V[S.top[1]];
        }
    }

	/**************end************/
}

void Pop(DblStack &S,int i)
{//删除指定的i号栈的栈顶元素，先出栈再移动指针
	/**************begin************/
if(!IsEmpty(S, i)) {       
        if(i == 0) {           
            cout << S.V[S.top[0]] << " ";
            --S.top[0];
        } else {               
            cout << S.V[S.top[1]] << " ";
            ++S.top[1];
        }
    }

	/**************end************/
}
int main()
{
  	DblStack S;
	int m,e0,e1,d0,d1;
	while(cin>>m)
	{
		if(m==0) break;
		InitDblStack(S,m);
      	cin>>e0>>e1>>d0>>d1;
		while(e0--)
			Push(S,0);
		while(e1--)
			Push(S,1);
      	cout<<IsFull(S)<<endl;
		while(d0--)
			Pop(S,0);
      	cout<<!IsEmpty(S,0)<<endl;
		while(d1--)
			Pop(S,1);
      	cout<<!IsEmpty(S,1)<<endl;
	}
	return 0;
}

第3关：基于栈的回文字符序列判断

任务描述
本关任务：回文序列是正反读均相同的字符序列,如“abba”和“abdba”均是回文，但是“good”不是回文。请设计一个算法判定给定的字符序列是否为回文。

编程要求
输入
多组数据，每组数据有一行。每一行为一个长度不定的字符序列A。当A为“0”时，输入结束。

输出
对于每组数据输出一行。若字符序列A是回文序列，则输出“YES”，否则输出“NO”。

测试说明
平台会对你编写的代码进行测试：

测试输入：
abba
abdba
good
0

预期输出：
YES
YES
NO

#include <iostream>
#include <cstring>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{
    char *base;
	char *top;
	int stacksize;
}SqStack;
int InitStack(SqStack &S)
{//栈初始化
	S.base=new char[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S, char e)
{//入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//出栈返回栈顶元素
	if(S.top==S.base)      //栈空
		return ERROR;
	S.top--;
	return *S.top;
}
int IsPalindrome(SqStack &S,char *t)
{//判断栈的回文字符序列
	/**************begin************/

    int len = strlen(t), mid = len / 2, i;
    for(i = 0; i < mid; i++)
    {
        Push(S, t[i]);
    }

    
    if(len % 2 == 1) 
	{
        i++;
    }

    
    for(; i < len; i++) 
	{
        char c = Pop(S);
        if(c != t[i]) 
		{
            return ERROR;
        }
    }

    return OK;

	/**************end************/
}
int main()
{
  	char t[100];
	while(cin>>t&&t[0]!='0')
	{
		SqStack S;
		InitStack(S);
		if(IsPalindrome(S,t)==1) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

第4关：入栈和出栈的基本操作

任务描述
本关任务：输入一个整数序列a1,a2,a3...,an。当ai不等于-1时将ai进栈；当ai=-1时，输出栈顶元素并将其出栈。

编程要求
输入
多组数据，每组数据有两行，第一行为序列的长度n，第二行为n个整数，整数之间用空格分隔。当n=0时输入结束。

输出
对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时，输出“POP ERROR”并结束本组数据的输出。

测试说明
平台会对你编写的代码进行测试：

测试输入：
5
1 2 -1 -1 1
5
1 -1 -1 2 2
0

预期输出：
2
1
1
POP ERROR

#include<iostream>
using namespace std;
#define  MAXSIZE  100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct
{
	int *base;
	int *top;
	int stacksize;
}SqStack;
int InitSqStack(SqStack &S)
{//栈的初始化
	S.base=new int[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S,int e)
{//入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//出栈
	if(S.top==S.base)  //栈空
		return ERROR;
	S.top--;
	return OK;
}
int GetTop(SqStack S)
{//取栈顶元素
	if(S.top==S.base)  //栈空
		return ERROR;
  	return *(S.top-1);
}
void InOutS(SqStack &S,int a[],int n)
{//入栈和出栈的基本操作
	/**************begin************/
  int i=0;
 while(i<n)
{
if(a[i]!=-1)
Push(S,a[i]);
else{
if(GetTop(S)==0)
{
cout<<"POP ERROR"<<endl;
i=n;
}
else
{
cout<<GetTop(S)<<endl;
Pop(S);
}
}
i++;}
	
		/**************end************/
}
int main()
{
	int n;
	while(cin>>n)
	{
      	if(n==0) break;
      	SqStack S;
		InitSqStack(S);
		int a[n];
		for(int i=0;i<n;i++) cin>>a[i];  //整数序列
		InOutS(S,a,n);
	}
	return 0;
}

第5关：基于栈的后缀算术表达式求值

任务描述
本关任务：从键盘上输入一个后缀表达式，试编写算法计算表达式的值。规定：后缀表达式的长度不超过一行，以“=”作为输入结束，操作数之间用空格分隔，操作符只可能有+、?、*、/四种运算。

编程要求
输入
多组数据，每组数据一行，对应一个后缀算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。

输出
对于每组数据输出一行，为表达式的运算结果。

测试说明
平台会对你编写的代码进行测试：

测试输入：
1 2+8 2-7 4-/*=
1 2+=
1 2/=
=

预期输出：
6.00
3.00
0.50

#include <iostream>
#include<iomanip>
#include <string>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//数字栈
	double *base;
	double *top;
	int  stacksize;
}SqStack;
int InitStack(SqStack &S)
{//数字栈初始化
	S.base=new double[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S,double e)
{//数字栈入栈
	if(S.top-S.base==S.stacksize)  //栈满
        return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//数字栈出栈
	if(S.top==S.base)    //栈空
		return ERROR;
	S.top--;
	return OK;
}
double GetTop(SqStack S)
{//数字栈取栈顶元素
	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
double Calculate(double a,char op,double b)
{//算术表达式的求值
    switch(op)
    {
        case '+':return a+b;
        case '-':return a-b;
        case '*':return a*b;
        case '/':return a/b;
    }
}
double EvaluateExpression(SqStack OPND,char s[])
{//后缀算术表达式求值
	/**************begin************/
int i = 0;
    while (s[i] != '=')
    {
        if (isdigit(s[i])) 
        {
            double num = 0.0;
            while (isdigit(s[i]))
            {
                num = num * 10 + (s[i] - '0');
                i++;
            }
            Push(OPND, num);
        }
        else if (s[i] != ' ') 
        {
            double b = GetTop(OPND);
            Pop(OPND);
            double a = GetTop(OPND);
            Pop(OPND);
            double result = Calculate(a, s[i], b);
            Push(OPND, result);
            i++;
        }
        else
        {
            i++;
        }
    }

    return GetTop(OPND); 


		/**************end************/
}

int main()
{
	char s[100];
	//用字符数组存储表达式，每个数组元素仅存一个字符
	while(1)
	{
		cin.getline(s,100);		//输入一行含空格的后缀表达式
		if(s[0]=='=') 
			break;				//当表达式只有一个"="时，输入结束
		SqStack OPND;
		InitStack(OPND);		//初始化数字栈
		cout<<fixed<<setprecision(2)<<EvaluateExpression(OPND,s)<<fixed<<setprecision(2)<<endl;
	}
	return 0;
}