数据结构-C描述-堆栈-简单计算器

最新推荐文章于 2024-04-27 23:54:07 发布
最新推荐文章于 2024-04-27 23:54:07 发布
阅读量520 收藏 8
点赞数 3
文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54077402/article/details/134725389
版权

1.实验需求

请按照四则运算加、减、乘、除、幂（^）和括号的优先关系和惯例，编写计算器程序。要求：

  • 从键盘输入一个完整的表达式，以回车作为表达式输入结束的标志。
  • 输入表达式中的数值均为大于等于零的整数。中间的计算过程如果出现小数也只取整。

例如，输入：4+2*5=                      输出：14

      输入：(4+2)*(2-10)=            输出：-48

2.概要设计

（1)抽象数据类型的定义：

采用两种栈（符号栈和数字栈）分别存储运算符和数字

两种栈都有各自的初始化、push、pop等函数

typedef struct{//符号栈 
	char *base;
	char *top;
	int stacksize;	
}Opstack;

typedef struct{//数字栈 
	int *base;
	int *top;
	int stacksize;	
}Numstack;

（2）主程序流程

主函数main

先定义栈符号栈和数字栈，定义一个数组ch临时存储输入的计算式初始化符号栈schar，调用PushOp函数在栈底放一个’=’，初始化数字栈snum，调用gets函数，将表达式临时存储在数组ch里，求数组长度。

在while循环（ch数组不到最后一个=或者schar不到栈底=）中，先判断现在所指数组元素是数字还是符号，如果是数字，调用Num函数将char型数字转换成int型，并将数字存储进数字栈，数组指针移动。如果是符号，调用Precede函数比较它和符号栈栈顶元素的优先级，如果栈顶元素优先级小于现在数组里的运算符，将该运算符进栈，移动数组指针；如果等于，栈顶元素出栈；如果大于，取数字栈栈顶两个元素，和符号栈栈顶元素，进行计算，再将结果压入数字栈。

循环结束，输出数字栈栈顶元素，即为结果。

（3)各模块介绍

由主程序main依次调用：

  1. int InitOpStack(Opstack &s)符号栈初始化函数
  2. int PushOp(Opstack &s, char e)符号栈进栈函数
  3. int InitNumStack(Numstack &s)数字栈初始化函数
  4. char GetTopOp(Opstack &s)符号栈取栈顶函数
  5. int In(char c)判断是运算符还是数字函数
  6. int Getnum(char ch[], int j)数组中char型数字转int型函数
  7. int PushNum(Numstack &s, int e)数字栈进栈函数
  8. char Precede(char c1, char c2)运算符优先级判断函数
  9. int PopOp(Opstack &s, char &e)符号栈pop函数
  10. int PopNum(Numstack &s, int &e)数字栈pop函数
  11. int Operate(int a, char theta, int b)运算函数

3.详细设计

（1）主函数main:

int main(){//主函数 
	Opstack schar;
	Numstack snum;
	char ch[100],x,theta;
	int a,b;
	int Num;
	int l;
	InitOpStack(schar);
	PushOp(schar,'=');//栈底压一个= 
	InitNumStack(snum);
	gets(ch);//把式子先存进去了 
	l=strlen(ch);
	while(ch[i]!='=' || GetTopOp(schar)!='=')
	{

		if(!In(ch[i])){//判断输入的是数字 
			Num=Getnum(ch,i);
			PushNum(snum, Num); 
		}
		else{
			switch(Precede(GetTopOp(schar),ch[i])){
				case '<':
					PushOp(schar,ch[i]);
					i++; 
					break;
				case '=':
					PopOp(schar, x); 
					i++;
					break;
				case '>':
					PopOp(schar, theta);
					PopNum(snum, b);
					PopNum(snum, a);
					PushNum(snum,Operate(a, theta, b));
					break;
					
			}
		}
	}
	printf("%d", GetTopNum(snum));
	return 0;
}

（2）数字栈的基本操作函数

int InitNumStack(Numstack &s){//创建数字栈 
	s.base = (int *)malloc(STACK_INIT_SIZE * sizeof(int));
	if(!s.base) exit(OVERFLOW);
	s.top = s.base;
	s.stacksize = STACK_INIT_SIZE;
	return OK;
}

int PushNum(Numstack &s, int e){//数字栈push函数 
	if(s.top - s.base >= s.stacksize){
		s.base = (int *)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(int));
		if (!s.base) exit(OVERFLOW);
		s.top = s.base + s.stacksize;
		s.stacksize += STACKINCREMENT; 
	}	
	*s.top++=e;
	return OK;
}

int PopNum(Numstack &s, int &e){//数字栈pop函数 
	if(s.top == s.base) return ERROR;
	e = *--s.top;
	return OK;
}

int GetTopNum(Numstack &s){//数字栈取栈顶 
	int e;
	if(s.top == s.base) return ERROR;
	e = *(s.top-1);
	return e;
}

（3）符号栈的基本操作函数

int InitOpStack(Opstack &s){//创建符号栈 
	s.base = (char *)malloc(STACK_INIT_SIZE * sizeof(char));
	if(!s.base) exit(OVERFLOW);
	s.top = s.base;
	s.stacksize = STACK_INIT_SIZE;
	return OK;
}

int PushOp(Opstack &s, char e){//符号栈push函数 
	if(s.top - s.base >= s.stacksize){
		s.base = (char *)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(char));
		if (!s.base) exit(OVERFLOW);
		s.top = s.base + s.stacksize;
		s.stacksize += STACKINCREMENT; 
	}	
	*s.top++=e;
	return OK;
}

int PopOp(Opstack &s, char &e){//符号栈pop函数 
	if(s.top == s.base) return ERROR;
	e = *--s.top;
	return OK;
}

char GetTopOp(Opstack &s){//符号栈取栈顶 
	char e;
	if(s.top == s.base) return ERROR;
	e = *(s.top-1);
	return e;
}

（4）判断数组中char型是运算符还是数字函数

 int In(char c)//判断是数字还是符号 
{
	if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='^'||c=='\n'||c=='=')
	return 1;
	else return 0;
}

（5）运算函数

int Operate(int a, char theta, int b){//运算函数 
	int num=0;
	switch(theta){
		case '+': num=a+b; break;
		case '-': num=a-b; break;
		case '*': num=a*b; break;
		case '/': num=a/b; break;
		case '^': 
			num = 1;
			while(b!=0) 
			{
				num *= a;
				b--;
			}
			break;
	} 
	return num;
}

（6）运算符优先级比较函数

输入两个运算符，运用二维数组构造一个类似表格一样结构查询两个运算符之间的关系，返回<,>,=

char Precede(char c1, char c2){//查表比较优先级 
	char levelTable[] = { '+', '-', '*', '/','^', '(',')','='};
	int m,n;
	char ch[8][8]={//查表！！！
	   {'>','>','<','<','<','<','>','>'},
	   {'>','>','<','<','<','<','>','>'},
	   {'>','>','>','>','<','<','>','>'},
	   {'>','>','>','>','<','<','>','>'},
	   {'>','>','>','>','>','<','>','>'},
	   {'<','<','<','<','<','<','=',' '},
	   {'>','>','>','>','>',' ','>','>'},
	   {'<','<','<','<','<','<',' ','='}
	};
	for(m=0;m<8;m++)
	{
		if(c1==levelTable[m]) break;
	 } 
	for(n=0;n<8;n++)
	{
		if(c2==levelTable[n]) break;
	} 
	return ch[m][n];
}

（7）char型转Int型函数

只要下一位还是数字，这个函数就会把数组里的数字组合成Int型的数字

4.总代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OK 1
#define ERROR 0 
#define TRUE 1
#define FALSE 0 

int i=0;//全局变量，用于判断字符是否全部进栈 

typedef struct{//符号栈 
	char *base;
	char *top;
	int stacksize;	
}Opstack;

typedef struct{//数字栈 
	int *base;
	int *top;
	int stacksize;	
}Numstack;


int InitOpStack(Opstack &s){//创建符号栈 
	s.base = (char *)malloc(STACK_INIT_SIZE * sizeof(char));
	if(!s.base) exit(OVERFLOW);
	s.top = s.base;
	s.stacksize = STACK_INIT_SIZE;
	return OK;
}

int InitNumStack(Numstack &s){//创建数字栈 
	s.base = (int *)malloc(STACK_INIT_SIZE * sizeof(int));
	if(!s.base) exit(OVERFLOW);
	s.top = s.base;
	s.stacksize = STACK_INIT_SIZE;
	return OK;
}


int PushOp(Opstack &s, char e){//符号栈push函数 
	if(s.top - s.base >= s.stacksize){
		s.base = (char *)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(char));
		if (!s.base) exit(OVERFLOW);
		s.top = s.base + s.stacksize;
		s.stacksize += STACKINCREMENT; 
	}	
	*s.top++=e;
	return OK;
}

int PushNum(Numstack &s, int e){//数字栈push函数 
	if(s.top - s.base >= s.stacksize){
		s.base = (int *)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(int));
		if (!s.base) exit(OVERFLOW);
		s.top = s.base + s.stacksize;
		s.stacksize += STACKINCREMENT; 
	}	
	*s.top++=e;
	return OK;
}

int PopOp(Opstack &s, char &e){//符号栈pop函数 
	if(s.top == s.base) return ERROR;
	e = *--s.top;
	return OK;
}

int PopNum(Numstack &s, int &e){//数字栈pop函数 
	if(s.top == s.base) return ERROR;
	e = *--s.top;
	return OK;
}


int In(char c)//判断是数字还是符号 
{
	if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='^'||c=='\n'||c=='=')
	return 1;
	else return 0;
}

char GetTopOp(Opstack &s){//符号栈取栈顶 
	char e;
	if(s.top == s.base) return ERROR;
	e = *(s.top-1);
	return e;
}

int GetTopNum(Numstack &s){//数字栈取栈顶 
	int e;
	if(s.top == s.base) return ERROR;
	e = *(s.top-1);
	return e;
}

int Operate(int a, char theta, int b){//运算函数 
	int num=0;
	switch(theta){
		case '+': num=a+b; break;
		case '-': num=a-b; break;
		case '*': num=a*b; break;
		case '/': num=a/b; break;
		case '^': 
			num = 1;
			while(b!=0) 
			{
				num *= a;
				b--;
			}
			break;
	} 
	return num;
}

char Precede(char c1, char c2){//查表比较优先级 
	char levelTable[] = { '+', '-', '*', '/','^', '(',')','='};
	int m,n;
	char ch[8][8]={//查表！！！
	   {'>','>','<','<','<','<','>','>'},
	   {'>','>','<','<','<','<','>','>'},
	   {'>','>','>','>','<','<','>','>'},
	   {'>','>','>','>','<','<','>','>'},
	   {'>','>','>','>','>','<','>','>'},
	   {'<','<','<','<','<','<','=',' '},
	   {'>','>','>','>','>',' ','>','>'},
	   {'<','<','<','<','<','<',' ','='}
	};
	for(m=0;m<8;m++)
	{
		if(c1==levelTable[m]) break;
	 } 
	for(n=0;n<8;n++)
	{
		if(c2==levelTable[n]) break;
	} 
	return ch[m][n];
}

int Getnum(char ch[], int j){//字符串转数字 
	int num=ch[j]-48;
	j++;
	while(ch[j]>='0'&&ch[j]<='9')//处理多位数字 
		num=num*10+ch[j++]-48;
	i=j;//处理到第几位了 
	return num;
}

int main(){//主函数 
	Opstack schar;
	Numstack snum;
	char ch[100],x,theta;
	int a,b;
	int Num;
	int l;
	InitOpStack(schar);
	PushOp(schar,'=');//栈底压一个= 
	InitNumStack(snum);
	gets(ch);//把式子先存进去了 
	l=strlen(ch);
	while(ch[i]!='=' || GetTopOp(schar)!='=')
	{

		if(!In(ch[i])){//判断输入的是数字 
			Num=Getnum(ch,i);
			PushNum(snum, Num); 
		}
		else{
			switch(Precede(GetTopOp(schar),ch[i])){
				case '<':
					PushOp(schar,ch[i]);
					i++; 
					break;
				case '=':
					PopOp(schar, x); 
					i++;
					break;
				case '>':
					PopOp(schar, theta);
					PopNum(snum, b);
					PopNum(snum, a);
					PushNum(snum,Operate(a, theta, b));
					break;
					
			}
		}
	}
	printf("%d", GetTopNum(snum));
	return 0;
}

5.运行结果

林远影
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
堆栈实现简单计算器
fourpoint的博客
05-11 1426
读入一个只包含加减乘除的非负整数计算表达式，计算表达式的值，整数和运算符之间用一个空格分隔。
L2-1 简单计算器 (25 分)详解c语言 模拟堆栈
聪聪冲
04-19 5235
L2-1 简单计算器 (25 分) 本题要求你为初学数据结构的小伙伴设计一款简单的利用堆栈执行的计算器。如上图所示，计算器由两个堆栈组成，一个堆栈 S​1存放数字，另一个堆栈 S​2 存放运算符。计算器的最下方有一个等号键，每次按下这个键，计算器就执行以下操作：从S ​1中弹出两个数字，顺序为 n​1和 n2 ；从 S​2中弹出一个运算符 op；执行计算 n​2 op n​1 ； 将得到的结果压回 S1​​ 。直到两个堆栈都为空时，计算结束，最后的结果将显示在屏幕上。 输入格式： 输入首先在第一行给
编程实现计算器。复习堆栈和队列的概念。用C语言编程实现一个简单的计算器，算术表达式中包括加、减、乘、除运算符和圆括号，并要求运算数是实型数。
m0_61529921的博客
05-22 867
#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <math.h> #define MAXSIZE 100 #define END '\n'//END是结束符 char ops[MAXSIZE]; //运算符栈 int ops_top; //运算符栈顶标识 double ovs[MAXSIZE]; //操作数栈 int ovs_top; ...
数据结构c语言计算器
12-09
一元多项式的加、减、乘的计算 内容为源代码，并有注释
HDU1237 简单计算器【堆栈】
海岛Blog
05-14 4984
简单计算器 Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 21518Accepted Submission(s): 7722 Problem Description 读入一个只包含 +, -, *, / 的非负整数计算表
堆栈实现的简单计算器
11-22
这是用堆栈实现的简单计算器，通过不断的对数字和操作符进行压栈和出栈的操作，达到计算效果
栈实现综合计算器（中缀表达式）
qq_43552242的博客
02-28 412
计算1+5*13等表达式 package com.hhit.stack; public class Calculator { public static void main(String[] args) { String expression = "70*2*2-5+1+1"; // 15//如何处理多位数的问题？ //创建两个栈，数栈，一个符号栈 ...
自己用C语言写的简单计算器，用堆栈实现
10-30
自己用C语言写的简单计算器，用堆栈实现，欢迎大家指正！
cpp-Clac一个命令行基于堆栈的计算器包含后缀符号
08-16
这个计算器利用了堆栈数据结构来执行计算，并且特别提到了后缀表达式，也被称为逆波兰表示法（RPN）。后缀表达式是一种数学表达式的表示方式，它在计算过程中避免了括号的使用，通过将运算符放在操作数之后来简化...
数据结构----课程设计(1)
06-05
一元稀疏多项式计算器 　【问题描述】 设计一个一元稀疏多项式简单计算器。简单LISP算术表达式计算器 ...　本课题主要是利用数据结构中堆栈部分知识进行解决，将初始表达式分别存入数据栈和运算符栈中进行处理。
数据结构实现的计算器 C语言版
07-12
实现了小数，负数的计算；实现了括号加减乘除优先级；实现了开方，次方。 用了栈这种数据结构，点开直接运行 main.c 这个文件
C语言数据结构之简易计算器
08-28
主要为大家详细介绍了C语言数据结构之简易计算器，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
堆栈实现的计算器(四则运算)功能
12-26
自己使用C，调用C++的Stack库实现的四则运算，可以支持0~9,+,-,*,/,(,),不支持错误检查。
简单计算器C语言数据结构栈实现
10-31
C语言数据结构栈的较高级应用
c语言小程序 计算器
06-17
本项目中提到的“C语言小程序计算器”是一个利用C语言编写的计算器程序，它不仅实现了基本的四则运算，还涉及到了数据结构的高级概念，如链表、堆栈和队列，以处理复杂的计算任务，特别是算符的优先级问题。...
C数据结构
weixin_41560737的博客
11-05 959
结构体的专项训练
计算命题演算公式真值(数据结构C语言版)实习报告.pdf
11-09
总的来说，这份实习报告描述了一个使用C语言和数据结构技术实现的命题演算公式真值计算器。它涉及到逻辑运算符的优先级、表达式的转换和计算、以及抽象数据类型的设计，是一份涵盖基础逻辑理论和程序设计的综合实践...
堆栈应用之简单计算器
shshbdhsjjd的博客
06-04 452
简单计算器 题目描述： 读入一个只包含+，-，*，/的非负整数计算表表达式，计算该表达式的值 输入格式： 测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应结果不要输出。 输出格式： 对每个从测试用例输出一行，即该表达式的值，精确到小数点后2位。 样例输入: 30 / 90 - 26 + 97 - 5 - 6 - 13 / 88 * 6 + 51 / 29 + 79 * 87 + 57 * 92 0 样例输出;
【C++数据结构】栈实现简单计算器（类模板）
最新发布
2301_80937868的博客
04-27 2313
栈的重要应用之一是表达式求值。本文以简单算术表达式为例展现这一应用。
请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,用C语言编写计算器程序
05-22
以下是一个简单的计算器程序，支持基本的加、减、乘、除、幂和括号运算： ``` #include <stdio.h> #include <stdlib.h> #include <math.h> #define MAX_EXPR_LEN 100 int is_operator(char c) { return c == '+' || c == '-' || c == '*' || c == '/' || c == '^'; } int is_digit(char c) { return c >= '0' && c <= '9'; } int priority(char c) { if (c == '+' || c == '-') return 1; else if (c == '*' || c == '/') return 2; else if (c == '^') return 3; else return 0; } double eval(char *expr) { char stack_op[MAX_EXPR_LEN]; double stack_val[MAX_EXPR_LEN]; int top_op = -1, top_val = -1; int i = 0; while (expr[i]) { if (expr[i] == '(') { stack_op[++top_op] = expr[i]; } else if (is_digit(expr[i])) { double val = expr[i] - '0'; while (is_digit(expr[i+1])) { val = val * 10 + (expr[++i] - '0'); } stack_val[++top_val] = val; } else if (is_operator(expr[i])) { while (top_op >= 0 && priority(stack_op[top_op]) >= priority(expr[i])) { char op = stack_op[top_op--]; double b = stack_val[top_val--]; double a = stack_val[top_val--]; double res = 0; switch (op) { case '+': res = a + b; break; case '-': res = a - b; break; case '*': res = a * b; break; case '/': res = a / b; break; case '^': res = pow(a, b); break; } stack_val[++top_val] = res; } stack_op[++top_op] = expr[i]; } else if (expr[i] == ')') { while (stack_op[top_op] != '(') { char op = stack_op[top_op--]; double b = stack_val[top_val--]; double a = stack_val[top_val--]; double res = 0; switch (op) { case '+': res = a + b; break; case '-': res = a - b; break; case '*': res = a * b; break; case '/': res = a / b; break; case '^': res = pow(a, b); break; } stack_val[++top_val] = res; } top_op--; } i++; } while (top_op >= 0) { char op = stack_op[top_op--]; double b = stack_val[top_val--]; double a = stack_val[top_val--]; double res = 0; switch (op) { case '+': res = a + b; break; case '-': res = a - b; break; case '*': res = a * b; break; case '/': res = a / b; break; case '^': res = pow(a, b); break; } stack_val[++top_val] = res; } return stack_val[top_val]; } int main() { char expr[MAX_EXPR_LEN]; printf("请输入表达式："); fgets(expr, MAX_EXPR_LEN, stdin); double result = eval(expr); printf("结果为：%g\n", result); return 0; } ``` 程序中使用了两个栈，一个用来存储运算符，一个用来存储数字。遍历表达式时，如果遇到数字，则将其转换为 double 类型并压入数字栈中；如果遇到运算符，则将其与运算符栈顶元素比较优先级，如果当前运算符优先级较低，则将栈顶运算符弹出，并从数字栈中弹出两个数进行计算，将计算结果压入数字栈中，直到栈顶运算符优先级低于当前运算符或栈空为止，然后将当前运算符压入运算符栈中。如果遇到左括号，则将其压入运算符栈中；如果遇到右括号，则弹出运算符栈中的元素，直到遇到左括号为止，并从数字栈中弹出两个数进行计算，将计算结果压入数字栈中。最后，再依次弹出运算符栈中的元素，进行计算，直到运算符栈为空，此时数字栈中的唯一元素即为表达式的值。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值