数据结构学习----计算器程序(栈的应用)

最新推荐文章于 2023-02-19 15:05:54 发布
最新推荐文章于 2023-02-19 15:05:54 发布
阅读量273 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 C C++ C# 

/********************************************************************************/
/*                            计算器程序                                    */
/*                                                                              */
/*                            2010-3-8                                         */
/*                                                                              */
/*    说明: Calculator类,用于通过给定四则运算表达式, 求出表达式的代数值         */
/*                                                                              */
/*    示例: #include <iostream>                                                 */
/*          #include <string>                                                   */
/*          #include "Calculator.h"                                             */
/*          void main()                                                         */
/*			{                                                                   */
/*			   string expression="2.3+(25-0.6*3.2^1.6)/(5-1.5^2)";              */
/*			   Calculator c(expression);                                        */
/*			   cout<<c.Run()<<endl;                                             */
/*             getchar();                                                       */
/*			}                                                                   */
/*                                                                              */
/*          输出:9.98791                                                        */
/*                                                                              */
/********************************************************************************/


//节点类, 用于保存浮点数[flag=0],或者运算符[flag=1]
#pragma region
class Item
{
public:
	Item(){}                       //构造函数
	Item(string _value,int _flag)  //重载构造函数
	{
		value=_value; flag=_flag;
	}
	string value;                  //保存浮点数,或者运算符
	int  flag;                     //标志位
	Item& operator=(Item& item)    //运算符重载
	{
		value=item.value;
		flag=item.flag;
		return *this;
	}
};
#pragma endregion


/*===================================================================================*/
/*                                                                                   */
/*                            各个算术操作符的优先级                                 */
/*  ------------------------------------------------------------------------------   */
/*  |   操作符   |     #    |    (    |    ^    |    * / %    |   + -   |    )   |   */
/*  ------------------------------------------------------------------------------   */
/*  |     isp    |     0    |     1   |    7    |      5      |     3   |    8   |   */
/*  ------------------------------------------------------------------------------   */
/*  |     icp    |     0    |     8   |    6    |      4      |     2   |    1   |   */
/*  ------------------------------------------------------------------------------   */
/*                                                                                   */
/*===================================================================================*/
#pragma region
int isp(string s)
{
	if(s=="#")
		return 0;
	if(s=="(")
		return 1;
	if(s=="^")
		return 7;
	if(s=="*"||s=="/"||s=="%")
		return 5;
	if(s=="+"||s=="-")
		return 3;
	if(s==")")
		return 8;
	return -1;
}

int icp(string s)
{
	if(s=="#")
		return 0;
	if(s=="(")
		return 8;
	if(s=="^")
		return 6;
	if(s=="*"||s=="/"||s=="%")
		return 4;
	if(s=="+"||s=="-")
		return 2;
	if(s==")")
		return 1;
	return -1;
}
#pragma endregion


#pragma region
class Calculator
{
public:
	string expression;                            //要计算的表达式
	DCirList<Item> inlist;                        //存储中缀表达式的链表
	DCirList<Item> postlist;                      //存储后缀表达式的链表
	LinkStack<Item> stack;                        //存储符号的栈
	LinkStack<float> result;                      //存储结果
	Calculator(string _expression);               //构造函数
	void GetInfix();                              //取得中缀表达式
	void GetPostfix();                            //取得后缀表达式
	float Run();                                  //求结果
};
#pragma endregion

#pragma region
Calculator::Calculator(string _expression)
{
	expression=_expression;
	expression.append(1,'#');
}

/*====================================================================================*/
/*                              字符串转中缀表达式算法:                               */
/*                                                                                    */
/* 一.从字符串第一个字符开始扫描,遇到数字或小数点,累加该字符到value中,直到遇到运算符. */
/*    将value, 以及此运算符存入到中缀表达式链表.                                      */
/* 二.如果字符串的最后一位为数字, 则扫描完后,直接将value存入到中缀表达式链表.         */
/*                                                                                    */
/*====================================================================================*/

void Calculator::GetInfix()
{
	string value="";  int flag=0;   Item node1,node2;
	for(int i=0;i<expression.length();i++)
	{
		if( (int)expression[i]==46||((int)expression[i]>=48&&(int)expression[i]<=57) )
		{
			flag=0;
			value.append(1,expression[i]);
			if(i!=expression.length()-1)
				continue;
			else
			{
				node1.value=value;      node1.flag=0;
				inlist.PushBack(node1);
				break;
			}

		} 
		if(value!="")
		{
			node1.value=value;          node1.flag=0;
			inlist.PushBack(node1);
		}
		node2.value=expression[i];      node2.flag=1;
		inlist.PushBack(node2); 
		value="";
	}
}

/*====================================================================================*/
/*                           中缀表达式转化成后缀表达式算法:                          */
/*                                                                                    */
/* 一.操作符栈初始化,将结束符#进栈,然后读取中缀表达式链表的首个结点元素item.          */
/* 二.重复执行以下步骤,直到读到item.value='#', 同时栈顶的操作符也是#, 停止循环.       */
/*    1.若item是操作数, 则存入后缀表达式链表,并读取下一个元素.                        */
/*    2.若item是操作符, 判断item的优先级icp和当前位于栈顶的操作符oper的优先级isp.     */
/*    3.(1)若icp(item.value)>isp(oper.value), 令item进栈,并读取下一个元素.            */
/*      (2)若icp(item.value)<isp(oper.value), 退栈, 并将此元素存入后缀表达式链表.     */
/*      (3)若icp(item.value)=isp(oper.value), 退栈, 若退出的是'(', 则读取下一个元素.  */
/*                                                                                    */
/*====================================================================================*/
void Calculator::GetPostfix()
{ 

	Item item("#",1); 
	stack.Push(item);
	item=inlist.PopFront();
	while(!stack.IsEmpty())
	{
		if(item.flag==0)
		{
			postlist.PushBack(item);
			item=inlist.PopFront();
		}
		else
		{
			Item oper=stack.GetTop()->data; 
			if(isp(oper.value)<icp(item.value))
			{
				stack.Push(item);
				item=inlist.PopFront();
			}
			else if(isp(oper.value)>icp(item.value))
			{
				postlist.PushBack(stack.Pop());
			} 
			else
			{
				if(stack.Pop().value=="(")
					item=inlist.PopFront();
			}
		} 
	}
}

/*====================================================================================*/
/*                         通过后缀表达式计算表达式的值算法:                          */
/*                                                                                    */
/*  顺序扫描后缀表达式链表的每一项,然后根据它的类型,做如下相应操作:                   */
/*  1.如果该项是操作数,则将其压入栈中;                                                */
/*  2.如果该项是操作符<op>,则连续从栈中弹出两个操作数Y,X,形成运算指令X<op>Y;          */
/*  3.将计算结果重新压入栈中;                                                            */     
/*  4.当表达式的所有项都扫描或处理完之后,栈顶存放的就是最后的计算结果.                */
/*====================================================================================*/
float Calculator::Run()
{
	float num1,num2;
	while(!postlist.IsEmpty())
	{
		Item item=postlist.PopFront();
		if(item.flag==0) 
			result.Push(atof(item.value.c_str())); 
		else
		{
			if(result.IsEmpty())
				Error("取右操作数失败!");
			num2=result.Pop();
			if(result.IsEmpty())
				Error("取左操作数失败!");
			num1=result.Pop();
			switch(item.value[0])
			{
			case '+': result.Push(num1+num2); break;
			case '-': result.Push(num1-num2); break;
			case '*': result.Push(num1*num2); break;
			case '/':
				{
					if(num2==0.0)
					{
						result.ClearStack();
						Error("Divide by 0 !"); 
					}
					else
						result.Push(num1/num2); break;
				}
			case '%': result.Push((int)num1%(int)num2); break;
			case '^': result.Push(pow(num1,num2)); break;
			}
		}
	}
	if(result.IsEmpty())
		Error("计算失败!");
	return result.Pop();
}
#pragma endregion

narcissus1001
关注
专栏目录
数据结构实现计算器 （完整，代码程序）
10-10
数据结构，计算器，非常好，适合学习，进步等等！
数据结构编写计算器
06-28
程序中主要运用堆栈这一数据逻辑结构。并建立了两个堆栈，当遇到 数字时直接压入操作数堆栈；当遇到加减乘除或左括号时进行优先级判断：如果传入的操作符优先级大于栈顶操作符的优先级则操作符入栈，如果传入的操作符优先级小于等于栈顶操作数的优先级则将栈顶操作符弹出，另外从操作数堆栈弹出两操作数进行运算，运算结果压入操作数堆栈；当遇到右括号时从两堆栈中弹出数据进行运算（每次结果压入操作数堆栈），直至遇到左括号从堆栈中弹出为止；当遇到等号时从两堆栈中弹出数据进行运算，直至操作符堆栈为空
《数据结构》-写的一个后缀表达式计算器程序
落叶漫飞
04-16 3524
mystack.h #define MAX_LEN 30 #define NO_ERR 0 //没有错误 #define ERR_STK_FULL -1 //堆栈已满 #define ERR_STK_EMPTY -2 //堆栈空 #define TYPE_SYMBOL 0 #define TYPE_NUMBER 1 typedef struct stack_t{ int stack[M
数据结构计算器
qq_43957263的博客
04-22 1732
摘要 通过对栈的应用实现‘+’，‘-’，‘*’，‘/’的运算，还包括‘（’，‘）’的应用。 算法思想 要想实现计算器，我们可以首先把中缀表达式转化为后缀表达式，再计算中缀表达式的值。 代码实现 #include<iostream> #include<stdlib.h> using namespace std; typedef struct{ int *top; int...
C++——数据结构 简单计算器
weixin_44546342的博客
04-26 2396
简单计算器 输入一个只包含 + - * / 运算符且运算数都为非负整数的表达式，请计算该表达式的值。 输入格式: 测试数据有多组。对于每组测试，输入一个字符串（长度不超过200）表示的表达式，整数和运算符之间用一个空格分隔。若输入0则输入结束，相应的结果不要输出。测试数据保证没有非法表达式。 输出格式: 对于每组测试，输出表达式的值，结果保留2位小数。 输入样例: 1 + 2 4 + 2 * 5 - 7 / 11 0 输出样例: 3.00 13.36 **出处: HDOJ 1237** 浙大计
数据结构课程设计-----简易计算器
03-05
通过这个课程设计，学生不仅能掌握数据结构的运用，还能提升编程技能，理解算法在实际问题中的应用。同时，这也是对软件工程基本原则的实践，包括模块化、测试和文档编写等。总的来说，这个项目是一个全面的编程挑战...
数据结构-3期（KC002） 计算器中进制转换功能设计.docx
07-14
在计算机科学中，数据结构和算法是核心组成部分，它们直接影响程序的效率和功能。本案例主要探讨了如何设计一个计算器的进制转换功能，特别是从十进制到其他进制（如二进制）的转换。以下是这个功能的详细解析： 1....
栈的应用-计算器实现
07-20
可执行程序可以实现数学计算公式的复杂运算。下载压缩包后需要减压文件，在目录下在linux命令行输入要计算的公式的字符串即可求出结果，例如在linux命令行下输入执行命令 ：./calculator "1+2*3-(6-3)*2+4-1" 即可求...
Swift-Calculator-app:用Swift编写的计算器应用程序
05-16
通过学习和实践这个Swift计算器应用，开发者不仅可以掌握Swift的基本语法，还能了解iOS应用开发的完整流程，包括UI设计、事件处理、数据存储和程序逻辑。同时，这也是一个很好的机会去探索更高级的主题，如自定义...
c++ QT 数据结构 栈计算器
04-09
总的来说，这个项目涵盖了C++编程、数据结构（栈的实现和应用）、基本的计算逻辑以及UI设计等多个方面，是学习和实践计算机科学基础的好例子。通过完成这样的项目，开发者可以提高编程技巧，理解数据结构的重要性，...
数据结构与算法：计算器实现（Python）
最新发布
爱出名的狗腿子
02-19 951
本文主要采用数据结构与算法的知识，采用Python语言，完成计算器的实现。其主要实现思路是： 1. 将人类易于理解的中缀表达式转化为计算机易于理解的后缀表达式； 2. 采用后缀表达式，栈操作实现算式运算
数据结构学习：简易计算器
Dffg_的博客
10-22 802
利用顺序栈，实现+、-、*、/、%运算，支持括号输入，可输入负数，暂不支持小数（也许不久的以后就实现了）。 #include <iostream> #include <string> #include <stdlib.h> #include <conio.h> #define N 50 using namespace std; /*定义顺序栈*/ template <class T> class ArrayStack { private:..
数据结构实现复杂计算器（自用）
m0_51666678的博客
07-02 1217
数据结构用栈实现复杂计算器，当时真的写的我快狗带了，终于在csdn里的小角落的评论里找到大佬的代码，真的肥肠厉害！ 计算器真的好难，需要考虑的东西有很多，多位数字判断该如何办呢，要求实现开方的话，小数要如何处理呢，要实现abs的话，负数也需要考虑。括号带括号的判断该怎么具体实现。以及错误的提示，输入了两个减号该怎么报错，等等等等。在细节各方面非常复杂，让人头疼。 ...
用栈实现的模拟计算器程序
a6644807的专栏
11-27 1216
#include #include #include #include //运算符栈数组长度 #define STACK_OPERATOR_LENGTH 100 //操作数栈数组长度 #define STACK_DATE_LENGTH 100 //定义运算符栈 typedef struct OPStack { //定义运算符数组 char opStack[STACK_OP
数据结构_calculator
weixin_34109408的博客
10-12 109
问题描述 小 V 发明了一个神奇的整数计算器：给定一个合法的表达式，这个计算器能求出这个表达式的最终答案。表达式可能包含：+：运算符，整数加法。如 1+1=2-：运算符，整数减法。如 1-1=0*：运算符，整数乘法。如 1*1=1/：运算符，整数除法。如 3/2=1(：左括号)：右括号操作数：保证为非负整数，且操作数没有正号（如不会出现+1 等）现在，给定一个表达式，小 V 在用这个计算器计算前...
2018年数据结构实验之计算器（栈的应用）
Jason7even的博客
02-12 688
2018年数据结构之计算器（栈的应用） 数据结构老师问我们“计算器实验和学生信息管理系统实验，你们选一个吧”，好多同学都说，管理系统C语言实训做过了，做计算器吧，加减乘除，好做。 好做？？？？我的老天爷…一会我贴出来，看代码长度就行了，/吐血！ 做实验那几周，恶心的要死要死的，有两天熬到了半夜三点还在debug。 栈的操作、括号匹配、处理负数、中缀表达式转后缀表达式、计算后缀表达式…第二恶心的是老...
数据结构- 栈（实现综合计算器）（一位数计算 扩展到 多位数计算）
chun的博客
10-03 395
思路 代码（可以看到这里的数字只能是单位数字，那么如何改成可以是多位数呢？！往下看） package stack; public class Calculator { public static void main(String[] args) { //完成表达式运算 String expression = "7+2*6-2*2"; //...
用c语言实现一个简单的计算器（数据结构）
热门推荐
诡白丷的博客
04-27 2万+
概要：主要对数据结构中写一个简易的计算器（计算整数间加减乘除括号运算）的算法进行大致讲述，细说如何去实现符号优先级的比较
数据结构（C语言）用链栈来实现计算器
qq_44024359的博客
11-22 1783
数据结构顺序栈实现简单计算器的操作 未改进，只能计算输出结果是个位数的数值计算 #include<stdio.h> #include<string.h> #include<malloc.h> #include<stdlib.h> #include<iostream> #define OK 1 #define ERROR 0 #define...
C语言栈实现：数据结构高级应用
"本篇文章主要介绍了如何使用C语言数据结构栈实现一个简单的计算器。文章首先定义了两个栈的数据结构：一个用于存储字符（`Sqstack`），另一个用于存储浮点数（`Sqstack1`）。栈是一种线性数据结构，遵循后进先出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值