数据结构实验项目二 栈的基本操作及其应用

最新推荐文章于 2023-04-08 00:15:00 发布
最新推荐文章于 2023-04-08 00:15:00 发布
阅读量2.7k 收藏 21
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44267044/article/details/103031827
版权

 

课程名称：数据结构

实验目的：

1．掌握栈的定义及实现；

2．掌握利用栈求解算术表达式的方法。

实验要求：

1、    使用链式存储结构完成栈的各种基本操作；

2、    补充完成In(c), Preced(t1,t2),Operate(a,theta,b)三个函数。

实验题目：栈的基本操作及其应用

实验过程：

1、通过修改完善教材中的算法3.22，利用栈来实现算术表达式求值的算法。对算法3.22中调用的几个函数要给出其实现过程：

(1) 函数In(c)：判断c是否为运算符；

(2) 函数Precede(t1,t2)：判断运算符t1和t2的优先级；

(3) 函数Operate(a,theta,b)：对a和b进行二元运算theta。

2、程序运行时，输入合法的算术表达式（中间值及最终结果要在0～9之间，可以包括加减乘除和括号），便可输出相应的计算结果。

 

实验提示：（仅供参考，每个函数的具体实现可以有多种方法，希望有创新）

1. 将栈的定义和实现单独保存在头文件“stack.h”中，然后在表达式求值的源程序中包含此头文件（即#include“stack.h”）。

2.表达式求值源程序的具体实现

(1) 主函数如下：

void main()

 {

   Printf(“请输入算术表达式,并以#结束.\n”);

  Printf(“the result of expression is:%d\n”,EvaluateExpression());

 }

(2) 函数EvaluateExpression的实现见算法3.22

(3) 函数In(c)的实现可以采用以下方式：

Status In(SElemType c)// 应在前面有定义typedef char SElemType;

 { // 判断c是否为运算符

   switch(c)

   {

     case'+':return TRUE;

     ……//补充完整

default:return FALSE;

   }

 }

(4) 函数Precede(t1,t2)的实现可以采用以下形式：

SElemType Precede(SElemType t1,SElemType t2)

 { //根据教材表3.1，判断两个运算符的优先关系

   SElemType f;

   switch(t2)

   {

     case '+':

     case '-':if(t1=='('||t1=='#')

                f='<';

              else

                f='>';

              break;

……//补充完整

}

   return f;

}

(5) 函数Operate(a,theta,b)的实现可以采用以下方式：

SElemType Operate(SElemType a,SElemType theta,SElemType b)

 {

   SElemType c;

   a=a-48;

   b=b-48;

   switch(theta)

   {

     case'+':c=a+b+48;

             break;

……//补充完整

   }

   return c;

 }

 

 

选做内容：进一步改进，使表达式的中间值及最终结果不局限于0～9之间的个位数。（如果完成要在实验报告中注明），如下图：

 

实验结果：

输入：2*（4-1）+8

输出：14

该程序能够完成个位数的四则运算。

实验分析：

1.栈的操作的特点；

2.列举调试运行过程中出现的错误并分析原因。

要求：

(1) 程序要添加适当的注释，程序的书写要采用缩进格式。

(2) 程序要具在一定的健壮性，即当输入数据非法时，程序也能适当地做出反应。

(3) 程序要做到界面友好，在程序运行时用户可以根据相应的提示信息进行操作。

(4) 上传源程序到课堂派，源程序保存为calculator.cpp。

#include<stdio.h> //运算过程不可出现一位以上数字
#include<iostream> 
using namespace std; 

#define MAXSIZE 100 
#define OK 1 
#define ERROR 0 
#define OVERFLOW -2 
#define TRUE 1 
#define FALSE 0 

typedef int Status; 
typedef char ElemType; 
typedef char SElemType; 

typedef struct StackNode 
{ 
	ElemType data; 
	struct StackNode *next; 
}StackNode,*LinkStack; 

Status InitStack(LinkStack &S) 
{ 
	S=NULL; 
	return OK; 
} 

Status Push(LinkStack &S,SElemType e) 
{ 
	LinkStack p=new StackNode; 
	p->data=e;
	p->next=S; 
	S=p; 
	return OK; 
} 

ElemType GetTop(LinkStack S) 
{ 
	if(S!=NULL) 
	return S->data; 
} 

Status Pop(LinkStack &S,SElemType &e) 
{ 
	if(S==NULL) return ERROR; 
	e=S->data; 
	LinkStack p=S; 
	S=S->next; 
	delete p; 
	return OK; 
} 

Status In(SElemType c) 
{ 
	switch(c) 
	{ 
		case'+':return TRUE; 
		case'-':return TRUE; 
		case'*':return TRUE; 
		case'/':return TRUE; 
		case'(':return TRUE; 
		case')':return TRUE; 
		case'#':return TRUE; 
		default:return FALSE; 
	} 
} 

SElemType Precede(SElemType t1,SElemType t2) 
{ 
	SElemType f; 
	switch(t2) 	
	{ 
		case '+': 
			if(t1=='('||t1=='#') 
				f='<'; 
			else 
				f='>'; 
			break; 
		case '-': 
			if(t1=='('||t1=='#') 
				f='<'; 
			else 
				f='>'; 
			break; 
		case '*': 
			if(t1=='+'||t1=='-'||t1=='('||t1=='#') 
				f='<'; 
			else 
				f='>'; 
			break; 
		case '/': 
			if(t1=='+'||t1=='-'||t1=='('||t1=='#') 
				f='<'; 
			else 
				f='>'; 
			break; 
		case '(': 
				f='<'; 
			break; 
		case ')': 
			if(t1=='(') 
				f='='; 
			else 
				f='>'; 
			break; 
		case '#': 
			if(t1=='#') 
				f='='; 
			else 
				f='>'; 
			break; 
	} 
	return f; 
} 

SElemType Operate(SElemType a,SElemType theta,SElemType b) 
{ 
	SElemType c; 
	a=a-'0'; 
	b=b-'0'; 
	switch(theta) 
	{ 
		case'+': 
		 	c=a+b+'0'; 
		 	break; 
		case'-': 
		 	c=a-b+'0'; 
		 	break; 
		case'*': 
		 	c=a*b+'0'; 
		 	break; 
		case'/': 
		 	c=a/b+'0'; 
		 	break; 
	} 
return c; 
} 

char EvaluateExpression() 
{ 
	LinkStack OPND;//装数字 
	LinkStack OPTR;//装运算符 
	InitStack(OPND);//初始化 
	InitStack(OPTR); 
	Push(OPTR,'#');//将表达式起始符起始符"#"压入OPTR栈 
	char ch; 
	cin>>ch; 
	while(ch!='#'||GetTop(OPTR)!='#') 
	{ 
		if(!In(ch)) 
		{ 
			Push(OPND,ch); 
			cin>>ch; 
		} 
		else 
			switch(Precede(GetTop(OPTR),ch)) 
			{ 
				case '<': 
				 	Push(OPTR,ch); 
			     	cin>>ch; 
			 		break; 
		 		case '>': 
				 	SElemType theta; 
				 	SElemType b; 
				 	SElemType a; 
				  	Pop(OPTR,theta); 
				 	Pop(OPND,b); 
				 	Pop(OPND,a); 
				  	Push(OPND,Operate(a,theta,b)); 
				 	break; 
				case '=': 
				 	SElemType x; 
				 	Pop(OPTR,x); 
				 	cin>>ch; 
				 	break; 
			}	 
	} 
	return GetTop(OPND); 
} 

int main() 
{ 
	printf("请输入算术表达式,并以#结束.\n"); 
	printf("The result of expression is:%c\n",EvaluateExpression()); 
} 
#include<iostream> //可进行多位数运算
#include<string.h> 
#include<string> 
using namespace std;

#define MAXSIZE 100 
#define OK 1 
#define ERROR 0 
#define OVERFLOW -2 
#define TRUE 1 
#define FALSE 0 

typedef int Status;
typedef string ElemType;
typedef string SElemType;

typedef struct StackNode
{
	ElemType data;
	struct StackNode* next;
}StackNode, * LinkStack;

Status InitStack(LinkStack& S)
{
	S = NULL;
	return OK;
}

Status Push(LinkStack& S, SElemType e)
{
	LinkStack p = new StackNode;
	p->data = e;
	p->next = S;
	S = p;
	return OK;
}

ElemType GetTop(LinkStack S)
{
	if (S != NULL)
		return S->data;
}

Status Pop(LinkStack& S, SElemType& e)
{
	if (S == NULL) return ERROR;
	e = S->data;
	LinkStack p = S;
	S = S->next;
	delete p;
	return OK;
}

Status In(ElemType c)
{
	char C = c[0];
	switch (C)
	{
	case'+':return TRUE;
	case'-':return TRUE;
	case'*':return TRUE;
	case'/':return TRUE;
	case'(':return TRUE;
	case')':return TRUE;
	case'#':return TRUE;
	default:return FALSE;
	}
}

SElemType Precede(SElemType T1, SElemType T2)
{
	SElemType f;
	char t1 = T1[0];
	char t2 = T2[0];
	switch (t2)
	{
	case '+':
		if (t1 == '(' || t1 == '#')
			f = "<";
		else
			f = ">";
		break;
	case '-':
		if (t1 == '(' || t1 == '#')
			f = "<";
		else
			f = ">";
		break;
	case '*':
		if (t1 == '+' || t1 == '-' || t1 == '(' || t1 == '#')
			f = "<";
		else
			f = ">";
		break;
	case '/':
		if (t1 == '+' || t1 == '-' || t1 == '(' || t1 == '#')
			f = "<";
		else
			f = ">";
		break;
	case '(':
		f = "<";
		break;
	case ')':
		if (t1 == '(')
			f = "=";
		else
			f = ">";
		break;
	case '#':
		if (t1 == '#')
			f = "=";
		else
			f = ">";
		break;
	}
	return f;
}

int string_to_int(SElemType a)
{
	int n = 0;
	for (int i = 0; i < a.size(); i++)
	{
		n = n * 10 + a[i] - '0';
	}
	return n;
}

SElemType Operate(SElemType a, SElemType Theta, SElemType b)
{
	SElemType c;
	int C;
	int A = string_to_int(a);
	int B = string_to_int(b);
	char theta = Theta[0];
	switch (theta)
	{
	case'+':
		C = A + B;
		break;
	case'-':
		C = A - B;
		break;
	case'*':
		C = A * B;
		break;
	case'/':
		C = A / B;
		break;
	}
	c = to_string(C);
	return c;
}

void judge(SElemType& S, ElemType& E, int& i)
{
	int n = 0;
	if (S[i] >= '0' && S[i] <= '9')
	{
		while (S[i] >= '0' && S[i] <= '9')
		{
			n = n * 10 + S[i] - '0';
			i++;
		}
		E = to_string(n);
	}
	else
	{
		E = S[i];
		i++;
	}
}


ElemType EvaluateExpression()
{
	LinkStack OPND;//装数字 
	LinkStack OPTR;//装运算符 

	InitStack(OPND);//初始化 
	InitStack(OPTR);

	Push(OPTR, "#");//将表达式起始符起始符"#"压入OPTR栈 

	SElemType S;
	cin >> S;

	ElemType E;
	int i = 0;
	judge(S, E, i);
	//	cout << "E: " << E << endl; 
	while (E != "#" || GetTop(OPTR) != "#")
	{
		if (!In(E))
		{
			Push(OPND, E);
			judge(S, E, i);
		}
		else
		{
			ElemType temp;
			char ch;
			temp = Precede(GetTop(OPTR), E);
			ch = temp[0];
			switch (ch)
			{
			case'<':
				Push(OPTR, E);
				judge(S, E, i);
				break;
			case'>':
			{
				SElemType theta;
				SElemType b;
				SElemType a;
				Pop(OPTR, theta);
				Pop(OPND, b);
				Pop(OPND, a);
				Push(OPND, Operate(a, theta, b));
				break;
			}
			case'=':
			{
				SElemType x;
				Pop(OPTR, x);
				judge(S, E, i);
				break;
			}
			}
		}

	}
	return GetTop(OPND);
}

int main()
{
	printf("请输入算术表达式,并以#结束.\n");
	printf("The result of expression is: ");
	ElemType ans = EvaluateExpression();
	cout << ans;
}

 

san lolo
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌数据结构链栈的基本操作及应用
05-18
头歌数据结构链栈的基本操作及应用 第1关链栈的基本操作 第2关链栈的应用——括号匹配 稳过 栈既可以采用顺序存储，也可以采用链接存储来实现。本实训项目的主要目标是学习和实现链接存储的栈。
BJFU_数据结构习题_241双栈的基本操作
雪地行进
10-26 3106
241双栈的基本操作 描述 将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空；当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见下图）。试编写双栈初始化，判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为：进栈、栈满的判断、出栈、栈空的判断。 双栈数据结构的定义如下： typedef ...
实验二，栈和队列的使用2021-10-27
MMarble的博客
10-27 722
实验报告内容基本要求参考格式 一、实验目的与实验环境 1．目的：熟练掌握应用两种数据结构栈和队列，完成对应的实验题目； 2. 实验环境：Window10 64位 ，Dev-C++ 二、实验内容 问题一： 【问题描述】假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。规定每个舞曲能有一对跳舞者。若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求写一个程序，模拟上述舞伴配对问题。(0<m,n,k<1000) 【输入形式
实验二栈和队列
qq_57611608的博客
06-04 3638
实验二 栈和队列 一、实验目的和要求 1、理解栈的存储结构及基本操作实现。 2、掌握应用栈解决问题的方法。 3、掌握队列的存储结构及基本操作实现，并能在相应的应用问题中正确选用它们。 二、实验仪器和设备 微型计算机 三、实验内容与过程 1、验证性实验：实现顺序栈的基本操作 实验内容：编写一个程序sqstack.cpp (或.c)，实现顺序栈的各种基本运算（假设栈中元素类型SElemType为char），并在此基础上设计一个程序exp3-1.cpp (或.c)完成以下功能。 (1) 初..
3.1双栈结构及其基本操作
qq_39688282的博客
08-17 2555
题目：将编号0和1的两个栈存放于一个空间V[m]的数组空间中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]=-1时该栈为空；当第1号栈的栈顶指针top[1]=m时，该栈为空。两个栈均从两端向中间增长（如下图）。试编写双栈初始化，判断栈空，栈满，进栈，出栈等算法的函数。 双栈结构的定义如下： typedef struct{ int top[2],bot[2];//栈顶和栈底指针 SElemType *V;//栈数组 in m;//栈最大可容纳元素的个数(也就是数组长度) }DblStack;
数据结构实验报告二、栈
qq_72560062的博客
04-08 3831
链栈
数据结构学习记录07——栈的定义及实现
*X||D*的博客
03-03 172
文章目录1.栈的定义及性质 1.栈的定义及性质   栈是一种特殊的线性表，是限定仅在表尾进行插入或删除操作的线性表。
程序填空题
大家一起入坑
12-26 5529
5-1 链栈入栈出栈操作。 #include<iostream> using namespace std; typedef char SElemType; typedef struct StackNode { SElemType data; struct StackNode *next; } StackNode, *LinkStack; int Push(LinkStack &S, SElemType e) { LinkStack p; p
数据结构顺序栈C++实现
Brillian123的博客
04-07 3172
栈，先入后出，根据存储方式可以分为顺序栈和链式栈。顺序栈的存储基于数组，链式栈的存储基于链表。 顺序栈就是以c语言的数组作为内存空间来构成的栈。栈顶指针top不再是c语言的指针类型，而是元素的下标。本文仍然使用模板的方法来实现，因为模板使用的内置数据类型较多，更全面。 1. 首先定义一下栈的通用接口，写在 “stack.h” 头文件中，通用接口为纯虚函数，方便顺序栈来继承和重写，以实现C++的多态。 “stack.h” 头文件代码如下： ...
数据结构实验报告-栈及其应用
最新发布
01-01
TYUT数据结构实验报告——栈及应用
c语言stack.h头文件 栈
11-13
c 语言 数据结构用的栈的头文件，可以让你直接引用，方便快捷
数据结构学习--栈及其应用
06-25
栈和对列是两种操作特殊的线性表，在实际中应用相当广泛...深入理解栈的特性，熟悉栈的基本操作，以便在实际问题背景下灵活运用它们，同时巩固对 这种结构的构造方法和掌握其运行过程，了解较复杂问题的递归算法设计。
栈和队列的基本操作及其应用数据结构实验报告书.docx
07-12
栈和队列的基本操作及其应用数据结构实验报告书.docx栈和队列的基本操作及其应用数据结构实验报告书.docx栈和队列的基本操作及其应用数据结构实验报告书.docx栈和队列的基本操作及其应用数据结构实验报告书.docx栈和...
数据结构实验-链表及栈的应用-天津理工大学
05-04
1、复习线性表（顺序表、链表）、栈（顺序存储、链式存储）、队列（顺序 存储、链式存储）的特点和基本操作；充分了解实验内容，进行问题分析，复习 相关知识并完成算法设计，初步完成程序设计，为实验作好充分的...
双向栈的基础操作
weixin_52957100的博客
10-03 2520
双向栈： 一个双向栈是在同一向量空间实现的两个栈，它们的栈底分别设在向量空间的两端。 双向栈有什么优点？ 入栈时，各自的栈顶向中间伸展，仅当两个栈的栈顶相遇时才可能发生上溢。由于两个栈之间可以做到互补余缺，使得每个栈的可利用空间均有可能超过n/2。这不仅减少了栈溢出的可能性，也增加了空间的利用率。 什么时候用双向栈？ 可以看到，当两个栈对空间的需求有相反关系的时候，也就是一个栈的空间增长，另一个栈的空间缩小时，可以使用双向栈。 在会手写栈的基础上，不难写出双向栈的代码。 下面给出本人写的C语言的双向栈（只
双栈的基本操作
代码行
04-02 3861
双栈：两栈共享向量空间，将两栈栈底设在向量两端，初始时，左栈顶指针为-1，右栈顶为n。栈顶指针相邻时为栈满，两栈顶相向增长。#include&lt;bits/stdc++.h&gt; using namespace std; typedef struct node { int top[2]; int bot[2]; int *V; int m; }node; voi...
数据结构双栈基本操作（C语言）
simtoba的博客
10-11 2264
#include <stdio.h> #include <stdlib.h> typedef int SElemType; typedef struct { int top[2],bot[2];//栈顶和栈底指针 SElemType *V;//栈数组 int m;//栈最大可容纳元素的个数(也就是数组长度) }SDblStack; void print(SDblStack &S) { int DblstackEmpty(SDblStack S); if(DblstackEmp
【数据结构】广义表的存储结构及基本运算（C语言）
weixin_51450101的博客
01-28 6426
目录1. 广义表基本概念2. 广义表的存储结构2.1 头尾链表存储结构2.2 同层结点链存储结构3. 广义表的基本运算3.1 求表头、表尾3.2 求长度、深度3.3 统计原子数目3.4 广义表的复制 1. 广义表基本概念 广义表是n个数据元素（d1,d2,d3,…,dn）的有限序列，di 既可以是单个元素，也可以是一个广义表。通常记作GL =（d1,d2,d3,…,dn），n是广义表长度。若其中 di 是一个广义表，则称 di 是广义表GL的子表。在广义表GL中，d1是广义表表头，其余部分组成的表称为广义表
重庆邮电大学数据结构实验
11-21
重庆邮电大学数据结构实验包括顺序表、链表、栈、队列、二叉树、图的遍历、查找算法和排序算法等内容。学生需要通过实验课程来掌握这些数据结构的基本概念、实现方法和应用场景。以下是每个实验的简要介绍： 1. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值