精华内容
下载资源
问答
  • 数据结构计算器

    2012-12-05 10:30:47
    c++数据结构算法,编计算器的实现,可视化界面。详细的教程
  • 数据结构计算器纯c

    2012-04-08 19:52:47
    数据结构计算器纯c
  • 软件介绍: 对于想学习保护模式和操作系统的同学,可以使用这个CPU基础数据结构计算器,输入HEX将自动计算相应值域。
  • 数据结构 计算器

    2010-10-18 12:43:07
    数据结构程序设计:用栈编写一个计算器。此为源代码.CPP格式
  • 对于学习保护模式和操作系统的朋友,提供些方便吧。 本来想免费分享给大家,资源分最低能设为2. 有问题和有bug,可以反馈到 nanxiaoming@126.com
  • 用户选择、整数转换、计算器.课程设计报告
  • 主要利用栈实现表达式求值,求阶乘,求平方,进制转换等功能。功能与界面模拟WINDOWS计算器,可支持鼠标。
  • 数据结构计算器实现ABS()和SQRT()

    千次阅读 2017-06-28 16:59:57
    递归实现的计算器,有大佬指导。虽然还有比较隐秘的BUG。#include #include #include #include #include #include using namespace std; int func_num(int num); double dfs(int

    递归实现的计算器,有大佬指导。虽然还有比较隐秘的BUG。

    #include <iostream>
    #include <algorithm>
    #include <cstdlib>
    #include <cstring>
    #include <cstdio>
    #include <cmath>
    using namespace std;
    int func_num(int num);
    double dfs(int l,int r);
    char str[1000+100];
    const int inf=0x3f3f3f3f;
    bool flagg;
    bool flag;
    inline void menu()
    {
        printf("********************************************\n");
        printf("* 郑重说明以下ABS()和SQR()均用A()和S()代替 *\n");
        printf("*             欢迎使用计算器               *\n");
        printf("*              1.继续使用                  *\n");
        printf("*                2.退出                    *\n");
        printf("********************************************\n");
        return ;
    }
    int main()
    {
        int choice;
        while(1)
        {
            menu();
            scanf("%d", &choice);
            switch(choice)
            {
            case 1:
                printf("请输入一个字符串\n");
                break;
            case 2:
                return 0;
                break;
            }
            getchar();
            gets(str);
            flagg = 0;
            flag=0;
            int len = strlen(str);
            if(len == 1 && str[0] == '0') break;
            double ans = dfs(0,len);
            for(int i=0; i<len; i++)
                if(str[i] == '.') flagg = 1;
            if(flag==1)
                printf("输入有误请重新输入\n");
            else
                printf("%.02f\n",ans);
        }
        return 0;
    }
    double dfs(int l,int r)
    {
        /*for(int i=l; i<r; i++)
            printf("%c",str[i]);
        printf("\n");*/
        if(flag==1)
            return 0;
        int num = 0, i = l;
        for(i=l; i<r; i++)
        {
            if(str[i] == '(') num += 1;
            if(str[i] == ')') num -= 1;
            if(!num && i != l)
                if(str[i] == '-' || str[i] == '+')
                    return dfs(l,i) + dfs(i,r);
    
        }
        for(i=l; i<r; i++)
        {
            if(str[i] == '(') num += 1;
            if(str[i] == ')') num -= 1;
    
            if(!num && i != l)
                if(str[i] == '*' || str[i] == '/')
                    return dfs(l,i) * dfs(i,r);
    
        }
        for(i=l; i<r; i++)
        {
            if(str[i] == '(') num += 1;
            if(str[i] == ')') num -= 1;
            if(!num && i != l)
                if(str[i] == 'A'||str[i]=='S')
                    return dfs(l,i) + dfs(i,r);
        }
        if(str[l] == '(')
        {
            l += 1 , r -= 1;
            return dfs(l ,r);
        }
    
        if(str[l] == '-')
            return -dfs(l+1,r);
        if(str[l] == '+')
            return  dfs(l+1,r);
        if(str[l] == '*')
            return dfs(l+1 , r);
        if(str[l] == '/')
        {
            int s=dfs(l+1, r);
            if(s==0)
            {
                flag=1;
                return 0;
            }
            return 1/s;
        }
        if(str[l]=='A')
            return fabs(dfs(l+1, r));
        if(str[l]=='S')
            return sqrt(dfs(l+1, r));
    
        double sum = 0;
        for(i=l; i<r; i++)
        {
            if(str[i] != ' ')
                sum = sum*10 + str[i] - '0';
        }
        return sum;
    }
    
    展开全文
  • 数据结构计算器

    千次阅读 2018-08-16 11:53:18
    Java数据结构计算器 先看看效果 表达式计算 平常我们数学中所计算的表达式 : 1.5+2*3+(5-6/2)= ? 如果在计算机中,应该如何计算该表达式? 涉及以下问题 根据运算符优先级,确定运算顺序。...

    这里写图片描述

    注: 除中缀表达式和后缀表达式算法外, 其余计算器的功能算法本人自己实现, 可能并不规范和标准, 并且可能存在一些BUG, 仅供参考.

    平常我们数学中所计算的表达式 :

    1.5+2*3+(5-6/2)= ?

    如果在计算机中,应该如何计算该表达式?

    涉及问题

    1. 根据运算符优先级,确定运算顺序。应先算括号里面的,后算括号外的,先算次方开方,后算乘除,最后算加减。
    2. 处理表达式错误问题,如出现其他字符,或者括号不匹配
    3. 功能完备,加入计算小数,负数,超大数的功能。

    运算顺序

    中缀表达式和后缀表达式

    平常我们计算的表达式也称中缀表达式,20世纪50年代,波兰逻辑学家Jan也遇到了运算优先级的问题,后来他发明了后缀表达式,解决了该问题。

    中缀表达式 :1.5+2*3+(5-6/2)

    转为后缀表达式 : 1.5 2 3 * + 5 6 2 / - +

    计算后缀表达式

    计算需要用到数据结构里的栈

    依次将后缀表达式的每个数字入栈
    这里写图片描述
    遇到运算符,从栈里出栈两个元素进行运算,随后再入栈
    这里写图片描述
    这里写图片描述
    按照此规则,继续进行下去
    这里写图片描述
    这里写图片描述
    这里写图片描述

    最后得出答案 9.5

    1.5+2*3+(5-6/2) = 9.5 可以口算一下

    相比起中缀表达式, 这样一步一步对后缀表达式的字符进行处理, 很容易用计算机的编程语言来实现

    如何转换后缀表达式

    同样要用到栈结构.

    转换运算规则如下:

    1. 遇到数字的话直接输出。
    2. 创建一个符号栈,遇到符号的话进栈.。同时需要设置符号优先级。因为先算加减,后算乘除,所以先假设 + - 优先级为 1, * / 优先级为为 2。 则在符号进栈时, 如果栈里有优先级大于或等于它( >= )的符号,则这些符号全部按顺序出栈,之后该符号再进栈。
    3. 遇到括号,左括号的话不做判别直接入栈,右括号不入栈,且要一直输出栈内的符号,直到遇到左括号为止。

    转换1.5+2*3+(5-6/2)为后缀表达式

    遇到数字输出, 遇到符号进栈。
    1.5输出 + 进栈 2输出
    这里写图片描述

    之后 * 进栈, 因为+的优先级不大于也不等于( >= ) * ,所以 + 不出栈 * 直接进栈。
    之后 3 输出
    这里写图片描述
    这里写图片描述

    之后是 + 号, 因为 栈里的 * 和 + 的优先级都大于或等于它( >= ), 所以* 出栈 + 出栈, 之后该 + 号再进栈
    这里写图片描述

    按此规则继续下去,遇到左括号( 直接入栈。

    这里写图片描述
    注: 这里入栈 - 号时虽然栈里有+号,但+号在括号的后面,所以不做判断,不用出栈。

    遇到右括号,则一直输出栈里内容直到左括号。

    这里写图片描述
    最后再输出+号 ,即可得到后缀表达式

    1.5 2 3 * + 5 6 2 / - +

    中缀转后缀表达式挨个检索每一个字符,之后进行处理,这种过程也适合用编程语言实现。

    ###中缀转后缀时处理小数,超大数和负数

    处理小数 超大数

    处理数字时需要循环处理
    例如读入 175.2
    首先创建一个空串 StringBuilder 循环判断 逐个字符读入 如果读入的是数字或小数点,则从末尾拼接到字符串里, 直到不为数字或小数点为止,最后如果字符串不为空, 则 调用 new BigDecimal(String str) 构造器把其构造成超大数.在加入栈里

    	String item = 175.2;
    	StringBuilder SB = new StringBuilder("");
        while (isNumber(c) || c == '.')
        {
            SB.append(c);
            if (++i >= item.length()) break;
            c = item.charAt(i);
        }
        if (!SB.toString().equals(""))
    	{   // StringBuilder没有重写equlas 需要调用String的eqluals
            stack.push(new BigDecimal(SB.toString()));
            // bigDecimal 超大浮点数
        }
    

    处理负数

    判断负号如果上一个字符读取的是运算符号,则给下一个读取到的数取反

    例如 3*-2, 定义一个布尔类型的开关值key 每次循环默认 false, 如果取到了一个符号,则 key = true, 如果key= true 且取到了 - 号 则在处理数字的字符串 StringBuilder上先拼接一个负号,之后继续取值

     StringBuilder SB = new StringBuilder("");
        if (c == '-' && key)
     {
        ++i;
        if(i < item.length())
        c = item.charAt(i);
        SB.append('-');
      }
       while (isNumber(c) || c == '.')
       {
       ......
       }
    

    表达式错误

    括号不匹配

    括号匹配同样需要用到栈

    例如表达式 1+2*(((1+3)+2)+4)

    挨个字符遍历表达式,
    遇到左括号 ‘’(’’ 则入栈, 遇到右括号则从栈里出一个括号, 如果栈为空则不匹配, 一直进行下去. 到最后所有括号都遍历过且栈为空则说明括号匹配,否则括号不匹配.

    出现错误字符

    开始时遍历一遍字符串, 遇到不符合算数的字符删除即可

    自己的实现

    加入了次方运算^ 调用的是Math.pow (double, double)
    超大数不能处理无线循环小数, 除法运算时需特殊处理,可以转成double类型运算.

    代码

    package JavaTest.caculater;
    
    
    import java.math.BigDecimal;
    import java.util.Scanner;
    import java.util.Stack;
    
    public class Caculater {
    
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String item = scanner.nextLine();
            Stack stack = new Stack();
            Stack stack1 = new Stack();
            boolean key = false;
            if(!pi(item))
            {
                System.out.println("括号不匹配");
                return;
            }
            for(int i = 0; i < item.length(); i++)
            {
    
                char c = item.charAt(i);
                while (!isfu(c) && !isNumber(c))
                {
                    ++i;
                    if(i < item.length())
                    c = item.charAt(i);
                    if( i == item.length())
                        break;
                }
                if( i == item.length())
                    break;
                StringBuilder SB = new StringBuilder("");
                if (c == '-' && key)
                {
                    ++i;
                    if(i < item.length())
                        c = item.charAt(i);
                    SB.append('-');
                }
                while (isNumber(c) || c == '.')
                {
                    key = false;
                    SB.append(c);
                    if (++i >= item.length()) break;
                    c = item.charAt(i);
                }
                if (!SB.toString().equals("")){
                    stack.push(new BigDecimal(SB.toString()));
    
                }
                if (c == '^')
                {
    
                    if((!stack1.empty()))
                        if( ((char)stack1.peek() == '^'))
                        {
                            stack.push(stack1.pop());
                        }
                }
                if (c == '*' || c == '/' || c == '+' || c == '-')
                {
    
                    if((!stack1.empty()))
                        if( ((char)stack1.peek() == '*') || ((char)stack1.peek() == '/') || ((char)stack1.peek() == '^'))
                        {
                           stack.push(stack1.pop());
                        }
                }
                if( c == '+' || c == '-')
                {
                    if((!stack1.empty()))
                        if( ((char)stack1.peek() == '*') || ((char)stack1.peek() == '/') || ((char)stack1.peek() == '+') || ((char)stack1.peek() == '-') || ((char)stack1.peek() == '^'))
                        {
                            stack.push(stack1.pop());
                        }
                }
                if (isfu(c))
                {
                    stack1.push(c);
                    key = true;
                }
                if(c == ')')
                {
                    char cha = c;
                    while (cha != '(') {
                         cha = (char) stack1.pop();
                         if(cha != '(' && cha != ')')
                             stack.push(cha);
                    }
                }
            }
            while (!stack1.empty())
            {
                stack.push(stack1.pop());
            }
            Stack stack2 = new Stack<>();
    
            while (!stack.empty())
            {
                stack2.push(stack.pop());
            }
            while (!stack2.empty()) {
                Object c = stack2.pop();
    //            System.out.println(c.getClass() + " " + c);
                if (c.getClass() == BigDecimal.class) {
                    stack1.push((BigDecimal) c);
    //                System.out.println(1);
                    continue;
                }
                else
                {
    //                System.out.println(2);
                    if ((char) c == '*' && (stack1.size() != 1))
                        stack1.push( ( (BigDecimal)stack1.pop() ).multiply( (BigDecimal) stack1.pop() ) );
                    if ((char) c == '^' && (stack1.size() != 1)) {
                        BigDecimal a = (BigDecimal) stack1.pop();
                    if(a.intValue() >= 1)
                        stack1.push(((BigDecimal) stack1.pop()).pow(a.intValue()));
                        else {
                            stack1.push(new BigDecimal(Math.pow(((BigDecimal) (stack1.pop())).doubleValue(), a.doubleValue())));
                       }
                    }
                    if ((char) c == '/' && (stack1.size() != 1)) {
                        Double a = ((BigDecimal) stack1.pop()).doubleValue();
                        stack1.push (new BigDecimal( ( (Double) ( ( (BigDecimal)stack1.pop() ).doubleValue() / a)).toString()));
                    }
                    if ((char) c == '+' && (stack1.size() != 1))
                        stack1.push(( (BigDecimal)stack1.pop() ).add( (BigDecimal) stack1.pop() ));
                    if ((char) c == '-')
                    {
                        BigDecimal a = (BigDecimal) stack1.pop();
                        if(!stack1.empty() && stack1.peek().getClass() != char.class )
                        {
                            stack1.push(((BigDecimal) stack1.pop()).subtract(a));
                        }
                        else
                            stack1.push((a).multiply(new BigDecimal(-1)));
                    }
                }
            }
            System.out.printf("%.6s",stack1.pop());
        }
        public static boolean isNumber(char c)
        {
            if (c >= '0' && c <= '9')
                return true;
            else
                return false;
        }
        public static boolean isfu(char c)
        {
            if(c == '+' || c == '-' || c == '*'|| c == '/' || c == '(' || c == '^')
                return true;
            else return false;
        }
    
        public static boolean pi(String string)
        {
            Stack<Character> stack = new Stack<Character>();
            for(int i = 0; i < string.length(); i++)
            {
    
                if(string.charAt(i) == '(')
                    stack.push('(');
                if(string.charAt(i) == ')')
                    if(stack.empty() || stack.pop() != '(')
                        return false;
            }
           if(!stack.empty())
               return false;
            return true;
        }
    
    }
    
    

    测试运行

    超大数
    这里写图片描述
    负数次方
    这里写图片描述
    开方
    这里写图片描述
    小数负数
    这里写图片描述
    括号匹配
    这里写图片描述
    错误字符删除处理
    这里写图片描述

    BUG肯定还存在, 后续还需继续改善。

    展开全文
  • 数据结构计算器

    2011-12-05 22:36:37
    用栈这种数据结构做的计算器,支持括号功能
  • 数据结构计算器

    2019-09-22 22:14:35
    数据结构计算器计算器的基本思想如下: 1.用两个栈分别用于保存运算符和操作数(也可能是局部的计算结果),可以分别称之为操作数栈和运算符栈。 2.依次扫描表达式中的基本符号(操作数的运算符均看作一个...

    数据结构 栈 计算器

    栈计算器的基本思想如下:

    1.用两个栈分别用于保存运算符和操作数(也可能是局部的计算结果),可以分别称之为操作数栈和运算符栈。

    2.依次扫描表达式中的基本符号(操作数的运算符均看作一个基本符号)。扫描到了操作数则压入操作数栈,运算符压入运算符栈。

             a. 如果扫描到的运算符优先级低于运算符栈顶的运算符,则运算符入栈,不发生运算。

             b. 如果扫描到的运算符优先级高于栈顶的运算符,则取出栈顶的运算符,接着取出操作数栈的两个操作数进行运算,并将结果入到操作数的栈中。

     

    #include<iostream>
    #include<string>
    
    using namespace std;
    
    enum status { FLASE, TRUE };
    
    template<class T>
    class stack
    {
    public:
    	stack();
    	~stack();
    	status empty();
    	status push(T x);
    	status pop();
    	T get_top();
    private:
    	struct node
    {
    	T data;
    	node *next;
    };
    	int count;
    	node *top;
    };
    
    template<class T>
    stack<T>::stack() 
    { 
    	count = 0;
    	top = NULL;
    }
    
    template<class T>
    stack<T>::~stack()
    {
    	while (!empty()) pop();
    }
    
    template<class T>
    status stack<T>::empty()
    {
    	if (count == 0) return TRUE;
    	else return FLASE;
    }
    
    template<class T>
    status stack<T>::push(T x)
    {
    	node *pnew=new node;
    	pnew->data = x;
    	pnew->next = top;
    	top = pnew;
    	count++;
    	return TRUE;
    }
    
    template<class T>
    status stack<T>::pop()
    {
    	if (empty()) cout << "已空" << endl;
    	node *pdelete;
    	pdelete = top;
    	top = pdelete->next;
    	delete pdelete;
    	count--;
    	return TRUE;
    }
    
    template<class T>
    T stack<T>::get_top()
    {
    	if (empty()) cout << "栈为空" << endl;
    	return top->data;
    }
    
    int symbol(char c)             //赋予优先级
    {
    	switch (c)
    	{
    	case '#': return 0;
    	case '+': return 2;
    	case '-': return 2;
    	case '*': return 3;
    	case '/': return 3;
    	case '(': return 4;
    	case ')': return 1;
    	default: break;
    	}
    	return 0;
    }
    
    int jisuan(int &a, int &b, char &c)
    {
    	switch (c)
    	{
    	case '+': return b + a;
    	case '-': return b - a;
    	case '*': return b * a;
    	case '/': return b / a;
    	default: break;
    	}
    	return 0;
    }
    
    void main()
    {
    	stack<int>s1;
    	stack<char>s2;
    	string a;
    	cout << "请输入" << endl;
    	cin >> a;
    	a = a + '#';
    	s2.push('#');
    	for (int i = 0; a[i] != 0; i++)
    	{
    		if (a[i] <= 47)                  //用阿斯克码判断扫描到的是数字还是运算符
    		{
    			if (a[i] == '#'&&s2.get_top() == '#') break; //两个#碰到一起运算结束
    			if (s2.get_top() == '(')   //括号特殊讨论
    			{
    				if (a[i] == ')')
    				{
    					s2.pop();
    					continue;
    				}
    				s2.push(a[i]);
    				continue;
    			}
    
    			else if (symbol(s2.get_top()) >= symbol(a[i])) //判断运算符优先级
    			{
    				char temp1 = s2.get_top();
    				s2.pop();
    				int temp2 = s1.get_top();
    				s1.pop();
    				int temp3 = s1.get_top();
    				s1.pop();
    				s1.push(jisuan(temp2, temp3, temp1));
    				i--;
    				continue;
    			}
    			else
    			{
    				s2.push(a[i]);
    				continue;
    			}
    		}
    		else                     //对数字的运算
    		{
    			int sum = static_cast<int>(a[i]) - 48;
    			for (; a[i + 1] > 47; i++)     //实现多位数的运算
    				sum = sum * 10 + static_cast<int>(a[i + 1]) - 48;
    			s1.push(sum);
    			continue;
    		}
    	}
    	int result = s1.get_top();
    	cout << "计算结果:" << endl;
    	cout << result << endl;
    }

    运行截图

    展开全文
  • 数据结构课程设计,采用双堆栈的多项式计算器
  • 计算器 数据结构

    2015-12-11 12:15:43
    本人做的计算器数据结构的,基本可以实现多项式的计算。大家看看吧
  • 数据结构栈作业,基于顺序栈的计算器,使用C++编写逻辑,QT制作ui
  • 数据结构复数计算器

    2013-04-26 13:26:06
    C语言复数计算器 实现复数的加减乘除 利用栈和队列的知识
  • 数据结构_计算器 C++ 用堆栈写的
  • 数据结构 复数计算器

    2012-09-26 13:04:58
    复数计算器 界面清晰 操作简单 可以提取复数的实部和虚部
  • 某福建大三本的某三本学院的数据结构作业,题号对应清华殷人昆版。有一些可能参考借鉴了网上的代码,大体应该都能运行(尤其是大作业),仅供参考
  • 数据结构简易计算器

    2012-04-22 13:09:32
    简易计算器自己改编的,功能实现到多位整数和浮点数!
  • 数据结构编写计算器

    2013-06-28 14:58:52
    程序中主要运用堆栈这一数据逻辑结构。并建立了两个堆栈,当遇到 数字时直接压入操作数堆栈;当遇到加减乘除或左括号时进行优先级判断:如果传入的操作符优先级大于栈顶操作符的优先级则操作符入栈,如果传入的操作...
  • 本科实验报告 实验名称 计算器 课程名称 数据结构 实验时间 任课教师 实验地点 良乡机房 实验教师 实验类型 原理验证 综合设计 自主创新 学生姓名 实验类型 原理验证 综合设计 自主创新 学号/班级 组 号 学 院 同组...
  • 数据结构 简易计算器

    万次阅读 2017-10-28 18:43:10
    主要解决了处理负数、小数等的基础运算操作,无图形界面#include #include using namespace std;class Calculator{ private: int Priority(char fuhao); double CalSuffix(string PostfixExp);...

    主要解决了处理负数、小数等的基础运算操作,无图形界面

    #include <iostream>
    #include <stack>
    using namespace std;
    
    class Calculator{
    private:
        int Priority(char fuhao);
        double CalSuffix(string PostfixExp);
    
    public:
        double Calculate(string InfixExp);
    
          string InfixToSuffix(string InfixExp);
    
    };
    
    double Calculator::CalSuffix(string PostfixExp){
        double tmpresult,ch1,ch2;
        double tmpnum,tmpxiaoshu=1;
        int i=0,tmpdashu;
        int isfu=0;  ///
        stack<double> stk2;
        while(PostfixExp[i]!='\0'){
            isfu=0;  ///
            if(PostfixExp[i]>=48&&PostfixExp[i]<=57){
                if(PostfixExp[i-1]=='-'){     /
                    isfu=1;
                }
                tmpxiaoshu=1;
                tmpdashu=10;
                tmpnum = PostfixExp[i]-48;
                while(PostfixExp[++i]>=48&&PostfixExp[i]<=57){
                    tmpnum = tmpnum*tmpdashu+ (PostfixExp[i]-48);
                }
                i=i-1;
                if(PostfixExp[++i]=='.'){
                    while(PostfixExp[++i]>=48&&PostfixExp[i]<=57){
                        tmpxiaoshu=tmpxiaoshu*0.1;
                        tmpnum = tmpnum + (PostfixExp[i]-48)*tmpxiaoshu;
                    }
                    i=i-1;
                }
                else{
                    i=i-1;
                }
                if(isfu){   
                    tmpnum=tmpnum*(-1);
                }
                stk2.push(tmpnum);
            }
    
            else if(PostfixExp[i]=='&'||PostfixExp[i]==' '){
            }
    
            else {
                if(PostfixExp[++i]>=48&&PostfixExp[i]<=57){
                    i=i-1;
                }
                else {
                    i=i-1;
                    ch2 = stk2.top();
                    stk2.pop();
                    ch1 = stk2.top();
                    stk2.pop();
                    switch(PostfixExp[i]){
                        case '+': tmpnum = ch1 + ch2; break;
                        case '-': tmpnum = ch1 - ch2;  break;
                        case '*': tmpnum = ch1 * ch2; break;
                        case '/': tmpnum = ch1 / ch2;
                            if(ch2==0) cout<<"除数为零";break;
                    }
                    stk2.push(tmpnum);
                }
            }
            i++;
        }
        if(stk2.empty()!=1){
          tmpresult = stk2.top();
          stk2.pop();
        }
        return tmpresult;
    }
    
    double Calculator::Calculate(string InfixExp){
        double result;
        result = CalSuffix(InfixToSuffix(InfixExp));
        return result;
    }
    
    int Calculator::Priority(char fuhao){
        switch(fuhao){
            case '+':
            case '-': return 2;
            case '*':
            case '/': return 3;
            case '(':
            case ')': return 1;
            default:
                return 0;
        }
    }
    string Calculator::InfixToSuffix(string InfixExp){
        stack<char> stk;
        string PostfixExp = "                  ";
        int i=0,j=0;
        char tmpfuhao;
        int flag = 0;  //判断多位数的头数是否为零
        while(InfixExp[i]!='\0'){
            if(InfixExp[i]>=48&&InfixExp[i]<=57){
                flag = 0;
                PostfixExp[j++]='&';
                PostfixExp[j++]=InfixExp[i];
                if(InfixExp[i]=='0'){
                    flag = 1;
                }
                while(InfixExp[++i]>=48&&InfixExp[i]<=57){
                    if(flag==0)
                        PostfixExp[j++]=InfixExp[i];
                    else
                        cout<<"输入错误数字";
                }
                i=i-1;
                if(InfixExp[++i]=='.'){
                    PostfixExp[j++]='.';
                    while(InfixExp[++i]>=48&&InfixExp[i]<=57){
                        PostfixExp[j++]=InfixExp[i];
                    }
                    i=i-1;
                }
                else{
                    i=i-1;
                }
            }
    
            else if(InfixExp[i]=='('){
                stk.push(InfixExp[i]);
            }
    
            else if(InfixExp[i]==')'){
                if(stk.empty()){
                   cout<<"表达式错误!";
                }
                else{
                   tmpfuhao = stk.top();
                   while(tmpfuhao!='('){
                       if(stk.empty()){
                           cout<<"表达式错误!";
                       }
                       else{
                           PostfixExp[j++] = '&';
                           PostfixExp[j++] = tmpfuhao;
                           stk.pop();
                           tmpfuhao = stk.top();
                       }
                    }
                    stk.pop();
                }
            }
    
            else if(InfixExp[i]=='+'||InfixExp[i]=='-'||InfixExp[i]=='*'||InfixExp[i]=='/'){
                if(i==0||((InfixExp[--i]<48||InfixExp[i]>57)&&InfixExp[i]!=')')){
                    i++;
                    PostfixExp[j++]='&';
                    PostfixExp[j++]='-';
                    while(InfixExp[++i]>=48&&InfixExp[i]<=57){
                        PostfixExp[j++]=InfixExp[i];
                    }
                    i=i-1;
                    if(InfixExp[++i]=='.'){
                        PostfixExp[j++]='.';
                        while(InfixExp[++i]>=48&&InfixExp[i]<=57){
                            PostfixExp[j++]=InfixExp[i];
                        }
                        i=i-1;
                    }
                    else{
                        i=i-1;
                    }
                }
                else{
                    i++;
                if(stk.empty()){
                    stk.push(InfixExp[i]);
                }
                else{
                    tmpfuhao = stk.top();
                    if(Priority(tmpfuhao)<Priority(InfixExp[i])){
                        stk.push(InfixExp[i]);
                    }
                    else{
                        while(Priority(tmpfuhao)>=Priority(InfixExp[i])){
                            PostfixExp[j++] = '&';
                            PostfixExp[j++] = tmpfuhao;
                            stk.pop();
                            if(stk.empty()!=1){
                               tmpfuhao = stk.top();
                            }
                            else break;
                        }
                        stk.push(InfixExp[i]);
                    }
                }
                }
            }
            else{
                cout<<"符号错误!";
                break;
            }
            i++;
        }
    
        while(!stk.empty()){
            tmpfuhao = stk.top();
            PostfixExp[j++] = '&';
            PostfixExp[j++] = tmpfuhao;
            stk.pop();
        }
        PostfixExp[j++] = '\0';
        return PostfixExp;
    }
    
    int main(int argc, const char * argv[]) {
        string a;
        Calculator a1;
        cin>>a;
        cout<<a1.Calculate(a)<<endl;
       cout<<a1.InfixToSuffix(a);
        return 0;
    }
    展开全文
  • 这是我自己编的一款用pascal语言编写的计算器
  • 简单计算器 模拟简单运算器的工作。假设计算器只能进行加减乘除运算,运算数和结果都是整数,四种运算符的优先级相同,按从左到右的顺序计算。 输入格式: 输入在一行中给出一个四则运算算式,没有空格,且至少有一个...
  • 精品文档 数据结构课程设计 实验报告 模拟计算器 班 级 学 号 姓 名 模拟计算器 1 欢迎下载 精品文档 1 问题描述 对于模拟计算器的设计实际便是利用栈对一个表达式求值的问题 要求 对包含加减乘除括号的任意整型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,277
精华内容 910
关键字:

数据结构计算器

数据结构 订阅