编程题实训-栈

已于 2023-11-04 23:20:33 修改
阅读量4.8k 收藏 61
点赞数 25
分类专栏： 数据结构--头歌 文章标签： 算法 数据结构
于 2023-11-04 14:59:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a61233/article/details/134216879
版权

超详解版

第1关：基于栈的中缀算术表达式求值

任务描述

本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。）

编程要求

输入

多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类型。

输出

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

#include <iostream>
#include<iomanip>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//运算符栈
    char *base;
	char *top;
	int stacksize;
}SqStack1;
int InitStack1(SqStack1 &S)
{//运算符栈初始化
	S.base=new char[MAXSIZE]; //1.分配内存空间 2.指向空间 
	if(!S.base) return OVERFLOW; //如果S.base为 NULL或0，则返回溢出的值。
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push1(SqStack1 &S, char e)
{//运算符栈入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop1(SqStack1 &S)
{//运算符栈出栈
	if(S.top==S.base)      //栈空
		return ERROR;
	S.top--;
	return OK;
}
char GetTop1(SqStack1 S)
{//运算符栈取栈顶元素
	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
typedef struct
{//操作数栈
	double *base;
	double *top;
	int  stacksize;
}SqStack2;
int InitStack2(SqStack2 &S)
{//操作数栈初始化
	S.base=new double[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push2(SqStack2 &S,double e)
{//操作数栈入栈
	if(S.top-S.base==S.stacksize)     //栈满
        return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop2(SqStack2 &S)
{//操作数栈出栈
	if(S.top==S.base)           //栈空
		return ERROR;
	S.top--;
	return OK;
}
double GetTop2(SqStack2 S)
{//操作数栈取栈顶元素
	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
double Calculate(double a,char op,double b)
{//计算表达式“a op b”的值
    switch(op)
    {
        case '+':return a+b;
        case '-':return a-b;
        case '*':return a*b;
        case '/':return a/b;
    }
}

char Precede(char a,char b)
{//比较运算符a和b的优先级
	if((a=='('&&b==')')||(a=='='&&b=='='))
		return '=';
	else if(a=='('||a=='='||b=='('||(a=='+'||a=='-')&&(b=='*'||b=='/'))
		return '<';
	else
		return '>';
}


double EvaluateExpression(SqStack1 OPTR,SqStack2 OPND,char s[])
{//算术表达式求值的算符优先算法
	/**************begin************/
	int i,x=0,e=0,flag=0;
	for(i=0;s[i]!='\0';i++){
		if('0'<=s[i]&&s[i]<='9'){
			flag = 1;//判断double类型是否处理完,1未完成
			x=x*10+(s[i]-'0');
			if(e!=0) e=e*10;
		}else if(s[i]=='.'){
			e = 1;
		}else{
			if(flag!=0){
				double number = x;
				if(e!=0) number = number/e;
				Push2(OPND,number);
				x=e=flag=0;
			}
			while(1){
				if(Precede(GetTop1(OPTR),s[i])=='<'){
					Push1(OPTR,s[i]);
					break;
				}else if(Precede(GetTop1(OPTR),s[i])=='>'){
					double b = GetTop2(OPND);
					Pop2(OPND);
					double a = GetTop2(OPND);
					Pop2(OPND);
					char oper = GetTop1(OPTR);
					Pop1(OPTR);
					Push2(OPND,Calculate(a,oper,b));
				}else{
					Pop1(OPTR);
					break;
				}
			}
		}
	}	
	return GetTop2(OPND);

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


int main()
{//设OPTR和OPND分别为运算符栈和操作数栈
	SqStack1 OPTR;
	InitStack1(OPTR);    //初始化OPND栈
	SqStack2 OPND;
	InitStack2(OPND);    //初始化OPTR栈
	Push1(OPTR,'=');     //将表达式起始符“=”压入OPTR栈        
	char s[100];
	while(cin>>s)
	{//循环读入多组数据
		if(s[0]=='=') 
		   break;    //当表达式只有一个“=”时，输入结束 
		//输出中缀算术表达式的值
		cout<<fixed<<setprecision(2)<<EvaluateExpression(OPTR,OPND,s)<<fixed<<setprecision(2)<<endl;
		
	}
	return 0;
}

double EvaluateExpression(SqStack1 OPTR,SqStack2 OPND,char s[])

         这个函数接收三个参数：一个名为OPTR的操作符栈，一个名为OPND的操作数栈，和一个字符数组s表示待求解的算术表达式。

主要逻辑:

这个函数主要通过遍历输入的算术表达式字符串s来处理每个字符。

a. 遍历表达式的每个字符:

对于每个字符s[i]，函数首先检查它是否是一个数字字符（0-9）。如果是，函数会将其转换为对应的整数值，并累加到当前的数值中。如果e不为0，说明当前的数值是一个小数，函数会相应地调整累加方式。

如果字符是一个小数点.，函数会设置一个标志e=1，表示接下来应该处理小数部分。

如果字符是一个运算符（比如+, -, *, /），函数会检查是否已经处理完了一个操作数的所有内容（由标志flag判断）。如果已经处理完了一个操作数，函数会将这个操作数存入OPND栈中，并重置相关变量。

然后，函数会使用一个循环来处理栈中优先级更高的运算符。具体来说，它会不断地从OPTR栈顶取出一个运算符，直到找到一个优先级低于当前运算符的运算符或者栈为空为止。

在这个过程中，函数会根据运算符的优先级从高到低进行相应的计算，并将结果存入OPND栈中。例如，如果当前运算符是乘法*，函数会取出栈顶的两个操作数，进行乘法运算，并将结果存入栈中。

b. 处理完一个运算符后:

如果遍历完整个表达式后，还有剩余的运算符没有处理，函数会继续从OPTR栈顶取出剩余的运算符并处理它们。

c. 返回结果:

最后，函数会返回栈顶的操作数作为整个表达式的计算结果。

第2关：双栈的基本操作

双栈共享一个地址连续的存储单元。即程序同时需要两个栈时，可以定义一个足够大的栈空间，该空间的两端分别设为两个栈的栈底

双栈结构的主要优点有：

  1. 可以有效利用栈空间，不需要移动大量元素，插入和删除元素时只需要移动栈顶指针，时间复杂度为O(1)。
  2. 可以同时处理两个栈，两个栈的添加和删除元素操作相互独立，因此可以实现多个栈共享同一个栈空间，提高空间利用率。

然而，双栈结构也存在一些缺点：

  1. 两个栈是此消彼长的关系，导致两个栈分别的栈长是动态变化的，无法确定。
  2. 双栈结构在实际运算过程中，一个栈有可能进栈元素多而体积大些，另一个则可能小些。因此，如果运算较为复杂或者长度为定值，可能会产生时间代价较高的问题。

在实际使用中，双栈结构适用于以下情况：

  1. 需要同时使用多个栈，并且每个栈的元素数量不确定，可能存在一个栈元素多而另一个栈元素少的情况。
  2. 需要尽可能减少元素的移动量，以加快处理速度。例如，在表达式求值等操作中，使用双栈结构可以减少元素的移动量，提高处理效率。
  3. 需要尽可能减少空间浪费。例如，如果给几个栈分配同样大小的空间，可能实际运行时，有的栈膨胀得快，很快就产生了溢出，而其他的栈可能此时还有许多空闲空间。使用双栈结构可以避免这种情况的发生。

任务描述

本关任务：将编号为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。整数之间用空格分隔。

#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(S.top[0]+1 == S.top[1]) return;
    int x;
    cin>>x;
    if(i==0) S.top[i]++;
    else S.top[i]--;
    S.V[S.top[i]] = x;


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

void Pop(DblStack &S,int i)
{//删除指定的i号栈的栈顶元素，先出栈再移动指针
	/**************begin************/
    if(S.top[i] == S.bot[i]) return; //栈空
    cout<<S.V[S.top[i]]<<" ";
    if(i==0) S.top[i]--;
    else S.top[i]++;
	/**************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”。

#include <iostream>
#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************/
    //1.入栈 2.按正常判断回文的思路走
    //出栈入栈的代码要烂熟于心
    int len = 0;
    for (int i = 0; t[i] != '\0'; i++) { // 先将输入字符串的所有字符压入栈中  
        Push(S, t[i]);  
        len++;
    }  
    for(int i = 0;i < len/2;i++){
        if(t[i] != Pop(S)) return 0;
    }
    return 1;

	/**************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;
}

        这段代码的目的是输入一个字符串，然后判断它是否是回文。每次输入一个字符串，就会进行一次这样的判断。如果输入的字符串是回文，程序会输出"YES"，否则输出"NO"。这个过程会一直循环进行，直到遇到空字符串或者用户按下结束输入的快捷键。 

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

任务描述

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

编程要求

输入

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

输出

对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时，输出“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************/
    for(int i = 0;i < n;i++){
        if(a[i]!=-1) Push(S,a[i]);
        else{
            if(S.top!=S.base){
                cout<<GetTop(S)<<endl;
                Pop(S);
            }else{
                cout<<"POP ERROR"<<endl;
                return;
            }
        }
    }
		/**************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. 中缀算术表达式（Infix Expression）：

在中缀表达式中，运算符位于两个操作数之间。因此，在计算时需要先从左到右扫描表达式，将操作数入栈，然后根据运算符进行计算。例如，对于表达式 "2 + 3"，首先将数字2和3入栈，然后根据"+"运算符进行计算，得到结果5。

在中缀表达式求值过程中，需要遵循从左到右的顺序进行计算，因此扫描表达式的顺序是关键。

  1. 后缀算术表达式（Postfix Expression）：

在后缀表达式中，运算符位于两个操作数之后。因此，在计算时需要先从左到右扫描表达式，将操作数入栈，然后根据栈顶元素进行计算。例如，对于表达式 "2 3 +"，首先将数字2和3入栈，然后根据栈顶的"+"运算符进行计算，得到结果5。

在后缀表达式求值过程中，需要遵循从右到左的顺序进行计算，因此栈的运用和操作顺序是关键。

总结：

基于栈的后缀算术表达式求值和中缀算术表达式求值的主要区别在于：

  1. 中缀表达式中，运算符位于两个操作数之间；而后缀表达式中，运算符位于两个操作数之后。
  2. 在求值过程中，中缀表达式需要从左到右扫描并计算，而后缀表达式需要从右到左扫描并计算。
  3. 中缀表达式需要遵循从左到右的计算顺序，而后缀表达式需要遵循从右到左的计算顺序。

任务描述

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

编程要求

输入

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

输出

运行分析 例如"1 2 + 8 2 - 7 4 - / * ="。

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

  1. 初始化一个空的栈OPND。

  2. 开始遍历输入字符串s：

  3. 1：这是一个数字，所以将其推入栈中：OPND = [1]

  4. 2：将其推入栈中：OPND = [1, 2]

  5. +：这是一个运算符，因此从栈中弹出顶部的两个数字，执行加法，并将结果推回栈中：OPND = [3]

  6. 8：将其推入栈中：OPND = [3, 8]

  7. 2：将其推入栈中：OPND = [3, 8, 2]

  8. -：这是一个运算符，因此从栈中弹出顶部的两个数字，执行减法，并将结果推回栈中：OPND = [3, 6]

  9. 7：将其推入栈中：OPND = [3, 6, 7]

  10. 4：将其推入栈中：OPND = [3, 6, 7, 4]

  11. -：这是一个运算符，因此从栈中弹出顶部的两个数字，执行减法，并将结果推回栈中：OPND = [3, 6, 3]

  12. /：这是一个运算符，因此从栈中弹出顶部的两个数字，执行除法，并将结果推回栈中：OPND = [3, 2]

  13. *：这是一个运算符，因此从栈中弹出顶部的两个数字，执行乘法，并将结果推回栈中：OPND = [6]

  14. =：这是表达式的结束。

#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,x=0,e=0,flag=0;
        //x和e辅助存储double型数
        //flag用于判断某个double类型数据是否读入完全
        for(i=0;s[i]!='=';i++)
        {
            if('0'<=s[i]&&s[i]<='9')
            {
                flag=1;
                x=x*10+(s[i]-'0');//x存储去掉小数点后的数据，如原数据1.23，最终得到的x为123
                if(e!=0) e=e*10;//小数点后有几位，e扩大为10的几倍
            }
            else if(s[i]=='.')
                e=1;
            else
            {
                if(flag!=0)
                {
                    double number=x;
                    if(e!=0) number=number/e;//如果其间有小数点出现,number缩小对应的倍数
                    Push(OPND,number);//将double类型数据入栈
                    x=e=flag=0;//复原x、e、flag
                }
                if(s[i]==' ') continue;
                double b=GetTop(OPND);
                Pop(OPND);
                double a=GetTop(OPND);
                Pop(OPND);
                char oper=s[i];
                Push(OPND,Calculate(a,oper,b));//将运算结果压入数字栈
            }
        }
        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;
}

第6关：基于栈的可操作判断 

任务描述

本关任务：假设I和O分别代表入栈和出栈操作。栈的始态和终态均为空。入栈和出栈的操作序列可以表示为仅由I和O组成的序列，称可操作的序列为合法序列，否则称为非法序列。请设计一个算法，判断所给的操作序列是否合法。若合法输出“true”，反之输出“false”。

编程要求

输入

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

输出

多组数据，每组数据为一行长度不定的操作序列A。当A为“0”时，输入结束。

#include <iostream>
#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)
{//入栈
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//出栈
	S.top--;
	return OK;
}
int IsEmpty(SqStack S)
{//判断栈是否为空，空返回1，否则返回0
	return S.top==S.base;
}
bool Judge(char a[],SqStack &S)
{//栈的可操作判断
	/**************begin************/
   int i = 0;
   //写循环前先思考是否知道运行次数
   while(a[i] != '\0'){ //'\0' 表示空字符(null字符)
    if(a[i] == 'I'){
        if(S.top - S.base == S.stacksize) return false;
        Push(S);
    }else if(a[i] == 'O'){
        if(S.top == S.base) return false;
        Pop(S);
    }
    i++;
   }
   return IsEmpty(S);
	/**************end************/
}
int main()
{
    char a[100];
    while(cin>>a)
    {
        if(a[0]=='0') break;
        SqStack op;
        InitStack(op);
        if(Judge(a,op)) cout<<"TRUE"<<endl;
        else cout<<"FALSE"<<endl;
    }
    return 0;
}

答案2

bool Judge(char a[],SqStack &S)
{//栈的可操作判断
	/**************begin************/
    //答案2
    int i = 0;
    while(a[i]!='\0'){
        switch(a[i]){
            case 'I':{
            if(S.top-S.base==S.stacksize) return false;
            else Push(S);
            break;
        }
        case 'O':{
            if(S.top == S.base) return false;
            else Pop(S);
            break;
        }
        }
        i++;
    }
    //判断栈的终态是否为空
    if(IsEmpty(S)) return true;
    else return false;
	/**************end************/
}

        本关主要是审题的问题，关于栈我们主要考虑是否栈满，是否栈空。 本题要求栈的始态和终态均为空，再加个判断条件就好了。

第7关：Ackermann函数的递归求值

任务描述

本关任务： 已知Ackermann函数定义如下：

,

写出计算Ack(m,n)的递归算法。

编程要求

输入

多组数据，每组数据有一行，为两个整数m和n。当m和n都等于0时，输入结束。

输出

每组数据输出一行，为Ack(m,n)。

#include<iostream>
using namespace std;
int Ack(int m,int n)
{//Ackermann函数的递归求值
    /**************begin************/
    if(m==0){
        return n+1;
    }else if(m > 0 && n == 0){
        return Ack(m-1,1);
    }else{
        return Ack(m-1,Ack(m,n-1));
    }

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

int main()
{
	int m,n;
	while(cin>>m>>n)
    {
        if(m==0&&n==0) break;
        cout<<Ack(m,n)<<endl;
    }
	return 0;
}

第8关：Ackermann函数的非递归求值

#include<iostream>
using namespace std;
#define MAXSIZE 100
int Ack(int m,int n)
{//Ackermann函数的非递归求值
/**************begin************/
     int tmp[m + 1][MAXSIZE];
    for (int j = 0; j < MAXSIZE; j ++)
        tmp[0][j] = j + 1;
    for (int i = 1; i <= m; i ++)
    {
        tmp[i][0] = tmp[i - 1][1];
        for (int j = 1; j < MAXSIZE; j ++)
            tmp[i][j] = tmp[i - 1][tmp[i][j - 1]];
    }
    
    return (tmp[m][n]);


    /**************end************/
}
int main()
{
	int m,n;
	while(cin>>m>>n)
    {
        if(m==0&&n==0) break;
        cout<<Ack(m,n)<<endl;
    }
	return 0;
}

假设我们要计算Ackermann(2, 1)，我们可以按照以下步骤进行计算：

  1. 初始化二维数组tmp，行数为3，列数为MAXSIZE。
  2. 初始化第一列：tmp[0][j] = j + 1，其中j从0到MAXSIZE-1。因此，tmp[0][0] = 1，tmp[0][1] = 2，tmp[0][2] = 3，以此类推。
  3. 计算tmp[1][0]：根据Ackermann函数的定义，我们有tmp[1][0] = tmp[0][1] = 2。
  4. 计算tmp[1][1]：根据Ackermann函数的定义，我们有tmp[1][1] = tmp[0][tmp[1][0]] = tmp[0][2] = 3。
  5. 计算tmp[1][2]：根据Ackermann函数的定义，我们有tmp[1][2] = tmp[0][tmp[1][1]] = tmp[0][3] = 4。
  6. 计算tmp[2][0]：根据Ackermann函数的定义，我们有tmp[2][0] = tmp[1][1] = 3。
  7. 计算tmp[2][1]：根据Ackermann函数的定义，我们有tmp[2][1] = tmp[1][tmp[2][0]] = tmp[1][3] = 5。
  8. 最后，我们返回tmp[2][1]的值，即得到了Ackermann(2, 1)的结果为5。

        这个例子可以帮助你理解如何使用一个二维数组来计算Ackermann函数的值。需要注意的是，Ackermann函数的值增长速度非常快，因此在实际应用中需要使用高精度计算或者使用递归来计算较大的输入值。

第9关：递归求解单链表中的最大值

任务描述

本关任务：利用单链表表示一个整数序列，利用递归的方法求出单链表中整数的最大值。

编程要求

输入

多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。

输出

对于每组数据分别输出一行，输出每个链表的最大值。

#include <iostream>
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
int GetMax(LinkList L)
{//递归求解单链表中的最大值
    /**************begin************/
   int max;
 	if(L->next==NULL)
 		 return L->data;
	else
 	{
		max=GetMax(L->next);
		return L->data>=max?L->data:max;
 	}
    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        L=L->next;    //指向首元结点
        cout<<GetMax(L)<<endl;
    }
    return 0;
}

在这段代码中，return L->data>=max?L->data:max; 将返回给调用该函数的上层调用者。这就是递归工作方式的核心。每次递归调用都会返回结果给上一层，直到到达链表的起始节点，然后结果返回给调用该函数的外部调用者。

例如，假设我们有一个链表，它的结构是这样的：

1 -> 2 -> 3 -> 4 -> 5

如果我们调用 GetMax(1)，那么函数会递归地调用 GetMax(2)、GetMax(3)、GetMax(4) 和 GetMax(5)。在每一步中，它会比较当前节点的值和当前的最大值，并将较大的值赋给 max。在最后一个递归调用中，GetMax(5) 会返回最大值（在这个例子中是5）给 GetMax(4)。然后这个过程会逐级向上进行，直到 GetMax(1) 返回最大值给外部的调用者。

第10关：递归求解单链表中的结点个数

任务描述

本关任务：利用单链表表示一个整数序列，利用递归的方法计算单链表中结点的个数。

编程要求

输入

多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。

输出

对于每组数据分别输出一行，对应链表中的各个结点个数。

#include <iostream>
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
int GetLength(LinkList L)
{//递归求解单链表中的结点个数
/**************begin************/
    if(!L->next) return 1;  //L指向表尾，返回1
    else return GetLength(L->next)+1;    //每递归一次，结点数加1


    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        L=L->next;    //L指向首元结点
        cout<<GetLength(L)<<endl;
    }
    return 0;
}

第11关：递归求解单链表中的平均值 

任务描述

本关任务：利用单链表表示一个整数序列，利用递归的方法计算单链表中各个结点的平均值。

编程要求

输入

多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。

输出

对于每组数据分别输出一行，对应链表中的各个结点的平均值，输出保留两位小数。

#include <iostream>
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
double GetAverage(LinkList L,int n)
{//递归求解单链表中的平均值
    /**************begin************/
    if(!L->next) return L->data;    //L指向表尾，返回其数值
    else
    {
        double ave=GetAverage(L->next,n-1);  //递归求解除尾结点外的其余n-1个结点的平均值
        return (ave*(n-1)+L->data)/n;       //返回平均值
    }
    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        L=L->next;//L指向首元结点
        printf("%.2f\n",GetAverage(L,n));//输出保留两位小数
    }
    return 0;
}

第12关：中缀表达式转化为后缀表达式 

任务描述

本关任务：输入一个中缀算术表达式，将其转换为后缀表达式。运算符包括+、-、*、/、(、)、=，参加运算的为小于10的自然数。（只考虑二元运算即可）

编程要求

输入

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

输出

对于每组数据输出一行，为表达式的后缀式。

#include<iostream>
using namespace std;
#define  MAXSIZE  100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define Status int
typedef struct
{
	char *base;
	char *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{//初始化栈
	S.base=new char[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
Status Push(SqStack &S, char e)
{//入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
Status Pop(SqStack &S)
{//出栈
	if(S.top==S.base)   //栈空
		return ERROR;
	S.top--;
	return OK;
}
char GetTop(SqStack S)
{//取栈顶元素
  	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
char Precede(char a,char b)
{//比较符号优先级
	if((a=='('&&b==')')||(a=='='&&b=='='))
		return '=';
	else if(a=='='||a=='('||b=='('||((a=='+'||a=='-')&&(b=='*'||b=='/')))
		return '<';
	else
		return '>';
}
void InfixToSuffix(SqStack op,char s[])
{//将中缀表达式转化为后缀表达式并输出 
    /**************begin************/
	 for (int i = 0; s[i] != '\0'; i++) {  
        if ('0' <= s[i] && s[i] <= '9') {  
            cout << s[i]; // 如果是数字，则直接输出  
        } else {  
            while (1) {  
                if (Precede(GetTop(op), s[i]) == '<') {  
                    Push(op, s[i]); // 如果栈顶操作符优先级小于当前操作符，将当前操作符压入栈中  
                    break;  
                } else if (Precede(GetTop(op), s[i]) == '>') {  
                    cout << GetTop(op); // 如果栈顶操作符优先级大于当前操作符，输出栈顶操作符并弹出  
                    Pop(op);  
                } else {  
                    Pop(op); // 如果栈为空，弹出栈中所有操作符  
                    break;  
                }  
            }  
        }  
    }  
    cout << endl; // 输出换行符，表示转换完成  
    
    /**************end************/
}
int main()
{
	SqStack op;
	InitStack(op);      //初始化字符栈op
	Push(op,'=');		//先在栈底放入'='便于以后比较符号优先级	
	char s[100];
	while(cin>>s)
	{
		if(s[0]=='=')
			break;    	//当表达式只有一个“=”时，输入结束 
		else
			InfixToSuffix(op,s); 	//将中缀表达式转化为后缀表达式并输出	
	}
	return 0;
}

        解析：该函数将中缀表达式转化为后缀表达式。遍历输入字符串，如果是数字则直接输出；如果是操作符，则与栈顶操作符比较优先级，如果栈顶操作符优先级小于当前操作符，则将当前操作符压入栈中；如果栈顶操作符优先级大于当前操作符，则输出栈顶操作符并弹出；如果栈为空，说明所有操作数都已经被处理，退出循环。最后输出换行符，表示转换完成。 

       

        

JAVA郑
关注
  • 25
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
编程练习题集——leetcode
weixin_45135434的博客
01-15 502
一、数组 1.1、简单 第1题 可被 5 整除的二进制前缀 给定由若干 0 和 1 组成的数组 A。我们定义 N_i：从 A[0] 到 A[i] 的第 i 个子数组被解释为一个二进制数（从最高有效位到最低有效位）。 返回布尔值列表 answer，只有当 N_i 可以被 5 整除时，答案 answer[i] 为 true，否则为 false。 示例1： 输入：[0,1,1] 输出：[true,false,false] 解释： 输入数字为 0, 01, 011；也就是十进制中的 0, 1, 3 。只有第一个数可
【数据结构】--栈的实现和多种例题
m0_74044018的博客
04-24 971
数据结构栈的概念，栈的实现，栈的几道经典面试题的详细讲解！
【 第4关：入栈和出栈的基本操作】【编程题实训-栈】【头歌】【bjfu-243】
Tommy_Nike的博客
10-29 6217
【头歌】【编程题实训-栈】【 第4关：入栈和出栈的基本操作】【bjfu-243】
编程实训-栈
2301_77276656的博客
03-27 801
编程实训-栈
编程题-绕圈排队
cquhehe的专栏
06-23 1039
题目时间限制：1秒 空间限制：32768K 牛家庄幼儿园为庆祝61儿童节举办庆祝活动,庆祝活动中有一个节目是小朋友们围成一个圆圈跳舞。牛老师挑选出n个小朋友参与跳舞节目,已知每个小朋友的身高h_i。为了让舞蹈看起来和谐,牛老师需要让跳舞的圆圈队形中相邻小朋友的身高差的最大值最小,牛老师犯了难,希望你能帮帮他。 样例: 当圆圈队伍按照100,98,103,105顺时针排列的时候最大身高差为5,其他排列
C语言实验实训 答案
11-09
C语言实验实训是计算机科学和技术专业学生的必修课程之一，旨在培养学生的编程能力和问题解决能力。在本实验报告中，我们将对C语言实验实训的答案进行详细的介绍和分析。 实验二：改错题、基本题和选做题 在实验...
《Python编程实训》试题.zip
06-11
这份"《Python编程实训》试题"提供了一系列的练习题，旨在帮助学习者深入理解和掌握Python语言的核心概念，以及解决实际问题的能力。以下是一些可能涵盖的知识点： 1. **基础语法**：包括变量声明、数据类型（如...
高级语言程序设计实训-2021年9月(1).rar
10-23
【高级语言程序设计实训】是计算机科学领域中的一个重要组成部分，主要目标是教授学生如何使用现代编程语言进行有效的软件开发。2021年9月的这个实训课程可能涵盖了一系列的主题，旨在帮助学生深入理解编程概念，并...
数据结构基于栈的算术表达式求值算法
11-25
对算法中调用的几个函数要给出其实现过程： (1) 函数In(c)：判断c是否为运算符； (2) 函数Precede(t1,t2)：判断运算符t1和t2的优先级； (3) 函数Operate(a,theta,b)：对a和b进行二元运算theta。
数据结构与实训习题答案
11-23
本资料集“数据结构与实训习题答案”提供了对这门学科关键概念的深入理解和实践应用的解答，旨在帮助学习者巩固理论知识并提升编程技能。 1. **链表**：链表是数据结构中的基本元素，不同于数组的连续存储，链表的...
java代码-实训5，题2
07-15
实训5的第二题可能涉及到了一个特定的编程挑战，但标题并未提供具体细节。不过，我们可以从常见的Java实训任务中推断出一些可能的知识点。 1. **基础语法**：`main.java` 文件通常包含程序的主入口点，这意味着我们...
头歌实践-编程题实训-栈的基本操作
UNUN549的博客
04-14 313
本关任务：输入一个整数序列a1,a2,a3...,an。当ai不等于-1时将ai进栈；当ai=-1时，输出栈顶元素并将其出栈。对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时，输出“POP ERROR”并结束本组数据的输出。多组数据，每组数据有两行，第一行为序列的长度n，第二行为n个整数，整数之间用空格分隔。当n=0时输入结束。
C++利用数组模拟栈进行中缀表达式求值--附源码 中缀表达式算法
Main666的博客
03-07 895
//中缀表达式求值 //方法：开两个栈，操作符栈和数组栈 //从左到右扫描中缀表达式 //1. 当前位为数字：继续向后扫描直到读取完整个数字，将其放入数字栈中 //2. 当前位为左括号，直接放入操作符栈中等待和右括号配对 //3. 当前位为右括号，从操作符栈中读取到上一个左括号之后的所有运算符， // 每读取一个就取数字栈中两个元素进行计算，并把结果放入栈中 //4. 当前位为运算符，如果栈顶元素优先级更高或者和当前运算符相等，就弹出 // 栈顶操作符，并进行计算，知道栈顶元素为左括号或者栈顶
数据结构头歌：2-1顺序栈-课上练
Sherry_liangtang的博客
11-15 881
数据结构头歌：2-1顺序栈-课上练
数据与结构实验二：栈
m0_73709731的博客
11-04 47
：+与栈顶元素比较，比栈顶元素优先级小，则一直出栈到+为老大为止，即出栈并打印*，之后+入栈，栈中元素为（假设左边为栈底）#+-：-与栈顶元素比较，比栈顶元素优先级大，则-入栈，栈中元素为（假设左边为栈底）#*（-*：*与栈顶元素比较，比栈顶元素优先级大，则*入栈，栈中元素为（假设左边为栈底）#*）：-（依次出栈，仅打印-，栈中元素为（假设左边为栈底）#*22：输出22，栈中元素为（假设左边为栈底）#*（-31：输出31，栈中元素为（假设左边为栈底）#（：（入栈，栈中元素为（假设左边为栈底）#*（
栈经典操作之中缀表达式的运算（C++）
soil980601的博客
09-29 1609
栈经典操作之中缀表达式的运算（C++）表达式介绍中缀表达式的运算逻辑C++代码 表达式介绍 中缀表达式：有运算优先级的算术表达式。eg：12+4(3+5)=34 后缀表达式：运算优先级排序完成的运算符在操作数之后的表达式，后缀表达式的计算为遇到运算符取运算符前最近的两个操作数进行相应的运算符计算。eg：13#4#2/+=13+4/2=15 中缀表达式的运算逻辑 中缀表达式转后缀表达式 转换过程需要两个栈，输出栈，运算符栈。 操作： 读入操作数，直接压入输出栈。 读入运算符，压入运算运算符号栈： ✳
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
最新发布
执梗的博客
07-23 1843
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
python基础编程课后习题及实训
11-26
Python基础编程课后习题及实训内容非常丰富多样，旨在帮助学生巩固基础知识并提升实际编程能力。具体内容包括但不限于以下几个方面： 1. 语法练习：通过编写简单的程序，熟悉Python的基本语法、数据类型和运算符等...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值