精华内容
下载资源
问答
  • 计算器的算法实现

    2017-10-14 22:12:00
    说点重点,计算器用到的知识点主要就是栈的应用,操作符进、出栈的处理,以及碰到括号的时候处理的方式。如果你C语言用的比较顺手,建议用C语言处理,能对栈的知识加强理解和应用。 本算法实现时,先将乘除运算处.....

    重点有:

    1. 将输入的表达式转化为逆波兰表达式
    2. 操作符进出栈处理
    3. 检测小数或多位数的情况
    4. 本算法实现采用从左向右计算

    想想学数据结构的时候还是大一下学期,转眼·····岁月是把猪食料。说点重点,计算器用到的知识点主要就是栈的应用,操作符进、出栈的处理,以及碰到括号的时候处理的方式。如果你C语言用的比较顺手,建议用C语言处理,能对栈的知识加强理解和应用。

    本算法实现时,先将乘除运算处理,之后剩余的加减从左向右一次计算。但还是希望你看下关于波兰表达式的知识。

    Python代码如下:

    import re
    you_put=input("输入你要计算的算式:\n")
    num_stack=[]#用于对数字的存储
    str_stack=[]#用于对操作符的存储
    i=0
    def cal(x,y,st):
        res=0
        x=float(x)
        y=float(y)
        if st is '+':
            res=x+y
        elif st is '-':
            res=x-y
        elif st is '*':
            res=x*y
        else:
            res=x/y
        return res
    def process(num_stack,str_stack):
        st = str_stack.pop()
        num_stack[len(num_stack) - 2] = cal(num_stack[len(num_stack) - 2],\
        num_stack[len(num_stack) - 1], st)
        num_stack.pop()
    while i<len(you_put):
        #判断扫描到的s[i]是操作数
        if you_put[i].isdigit():
            #当数值为多位数时,采用正则匹配
            num=(re.search(r'(\d+)',you_put[i:])).group()
            length=len(num)
            #先将'*'或者'/'计算出结果。例如:1-2*3-->1-6
            if len(num_stack)>0 and str_stack[len(str_stack)-1] in ['*','/']:
                num=cal(num_stack[len(num_stack)-1],num,str_stack[len(str_stack)-1])
                num_stack[len(num_stack)-1]=num
                str_stack.pop()
            else:
                num_stack.append(num)
            i+=length
            continue
        if you_put[i] is '(':
            #扫描到的s[i]是开括号'(',将s[i]压栈;
            str_stack.append(you_put[i])
            i+=1
            continue
        if you_put[i] in ['+','-','*','/','(']:
            #栈顶为'(' 或 扫描到的操作符优先级比栈顶操作符高
            if you_put[i] in ['*','/','(']:
                str_stack.append(you_put[i])
                i+=1
                continue
            else:
                if len(str_stack)==0:
                    str_stack.append(you_put[i])
                    i += 1
                    continue
                elif str_stack[len(str_stack)-1] in ['*','/']:
                    process(num_stack,str_stack)
                    str_stack.append(you_put[i])
                    i+=1
                    continue
                else:
                    str_stack.append(you_put[i])
                    i+=1
                    continue
        if you_put[i] is ')':
            while str_stack[len(str_stack)-1] is not '(':
                process(num_stack, str_stack)
            str_stack.pop()    #弹出'('
            i+=1
    while len(num_stack)>1:
        #因为之前已经将'*','/'计算过,所以现在仅剩'+','-'
        temp=0
        st = str_stack.pop(temp)
        num_stack[temp+1] = cal(num_stack[temp],num_stack[temp+1], st)
        num_stack.pop(temp)
    print(num_stack[0])

    运行结果截图如下:

    测试较少,如有错误或不妥之处,请多指出。

    转载于:https://www.cnblogs.com/xsmile/p/7668775.html

    展开全文
  • 有括号的表达式可以通过这个思路延伸出来) 一、分析 数学表达式求值、计算器求值都是根据运算符优先级来进行相应计算的。 怎么处理符号的优先级是非常重要的。 我以前学过用栈来求解表达式,但是需要个复杂的...

    日常学习中总是能遇到做计算器的时候。今天,我就简单介绍一下我想的表达式求值方法。(有括号的表达式可以通过这个思路延伸出来)

    一、分析

    数学表达式求值、计算器求值都是根据运算符优先级来进行相应计算的。
    怎么处理符号的优先级是非常重要的。

    我以前学过用栈来求解表达式,但是需要个复杂的运算符优先级数组,这个数组很难记忆,不方便使用。

    但优先级大小完全可以用数值大小来表示,数值也能有优先级。
    在这里插入图片描述

    二、解决办法

    优先级处理:
    1、将 *、/ 、%运算符优先级定义为3。(括号优先级可以定为4)
    2、将 +、- 运算符优先级定义为2。
    3、将数值(1、2.5这种)优先级定义为1。
    4、= 号优先级可有可无,想用就设为0。

    数值处理
    1、0-9正常大小
    2、“+”大小为10,“-”大小为11,“*”大小为12,“/”大小为13,“%”大小为14

    用两个数组保存主要数据,一切操作围绕数组进行。

    通过代码注释讲解

    String function(String str){//按下等号
        
        int lg = str.length;	//得到字符串长度
        String ms = str;	//复制字符串
        float ary[20];	//保存数值,(=-*/%)对应(10、11、12、13、14)
        float ary2[20];	//保存优先级	,3、2、1、0
        float s = 0.0;	//储存结果
    
        int i = 0,j = 0;
        int t = 0;	//表示数值个数,ary数组已使用空间大小
        int flag = 0;	//
        float num = 0.0;	//字符串转浮点数要用
        String temp = "";	//存储得到的数值字符串
        int max = 0;	//比较优先级
        int mf = 0;		
        int left = 0;
        int right = 0;
        
        //遍历字符串,将字符串信息提取为数值数组和优先级数组
        for(i = 0;i < lg;i++) {
          //如果到达字符串结尾,保存最后一位数到ary数组中
          if(i==(lg-1)){
            temp = ms.substring(flag,lg);  //得到对应的数值字符串
            num = parseFloat(temp); //字符串转浮点数
            ary[t] = num; //对应位赋值
            ary2[t] = 1;	//优先级为1
            t++;
          }
          //如果检测到是运算符,得到运算符之前的数并保存,然后保存运算符及其优先级
          if(ms.charAt(i)=="+" || ms.charAt(i)=="-" || ms.charAt(i)=="*" || ms.charAt(i)=="÷" || ms.charAt(i)=="%"){
            temp = ms.substring(flag,i);  //得到对应的数值字符串
            num = parseFloat(temp); //字符串转浮点数
            ary[t] = num; //对应位赋值
            ary2[t] = 1;
            t++;
            switch(ms.charAt(i)){
              case "+":
                ary[t] = 10;	//加号大小定义为10,优先级是2
                ary2[t] = 2;
                break;
              case "-":
                ary[t] = 11;
                ary2[t] = 2;
                break;
              case "*":
                ary[t] = 12;	//乘号大小定义为12,优先级为3,其他类似
                ary2[t] = 3;
                break;
              case "÷":
                ary[t] = 13;
                ary2[t] = 3;
                break;
              case "%":
                ary[t] = 14;
                ary2[t] = 3;
                break;
            }
            flag = i+1; //标记运算符在的位,方便之后得到数
            t++;
          }
        }
        
        //上面得到了二个数组
        //例子:2+3.2*7
        //ary:	2		10		3.2		12		7
        //ary2:	1		2		1		3		1
     	//根据两个数组处理字符串
     	//*********************************************************
     	//找出最高优先级的操作,再找出左右最近的两个操作数(优先级为1)
     	//执行该运算操作
     	//将结果赋值到左操作数上,其他位对应的优先级置0
     	//循环该过程,直到最高优先级为1时结束
     	//此时,表达式只剩下了结果保存在ary[0]中
     	//********************************************************
        for(i = 0;i < t;i++){
          max = 0;
          for(j = 0;j < t;j++){
            if(ary2[j]>max){
              max = ary2[j];
              //left:左操作数下标,right:右操作数下标,mf运算符下标
              left = right = mf = j;	
            }
          }
          
          if(max == 1){
            //结束标志
            return str + "=" + s;
          }
          while(ary2[left]!=1){	//得到左操作数
            left--;
          }
          while(ary2[right]!=1){//d得到右操作数
            right++;
          }
          //执行运算符操作
          switch(ary[mf]){
            case 10:
              s = ary[left] + ary[right] ;
              break;
            case 11:
              console.log(11);
              s = ary[left] - ary[right];
              break;
            case 12:
              console.log(12);
              s = ary[left] * ary[right];
              break;
            case 13:
              console.log(13);
              s = ary[left] / ary[right];
              break;
            case 14:
              console.log(14);
              s = ary[left] % ary[right];
              break;
          }
          ary[left]=s;	//将结果保存在左操作数位置上
          
          for(int k = left+1;k <= right;k++){
            ary2[k] = 0;	//将运算符及右操作数优先级置0
          }
          
        }
        
      }
    }
    //例子:2+3.2*7	,两个数组最后的值
    //ary:	24.4		10		22.4		12		7
    //ary2:	1			0		0			0		0
    

    这个算法我就用了2个数组就解决了,今天能想到这个方法,有点小高兴!!

    展开全文
  • 计算器的加减乘除处理ok,按键位图,声音制作,加载均已经ok,该括号进入表达式了,括号优先级最高,先处理,括号有两种,一种并行,比如:(1+2)+(3+4)+(5+6),另一种嵌套,比如:(3*(4+5*(6+7/(8+9))))...

    计算器的加减乘除处理ok,按键的位图,声音制作,加载均已经ok,该括号进入表达式了,括号优先级最高,先处理,括号有两种,一种并行,比如:(1+2)+(3+4)+(5+6),另一种嵌套,比如:(3*(4+5*(6+7/(8+9))))),看到嵌套,一种熟悉的感觉油然而生,在以前,可是避之不及,首先想到的是堆栈,其次想到的是递归,傅里叶变换中已经用到(奇偶拆分序号排序),再就是findblob(找斑)的染色算法中也用到,参考后(前面章节有讲到),反复修改测试后,'('')'括号优先级处理递归算法如下:

    1,假定有字符串, string str = "(3+4*(8+2))*5/(6-2*(8-4))+8*(3+2)";

    2,然后调用, 括号优先级处理递归算法(ref str);

     public void  括号优先级处理递归算法(ref  string tempstr)
            { 

     if (tempstr[n] == '(')             
                    {
                        //截取字符串,调用自己
                        string subpstr = tempstr.Substring(n+1 , tempstr.Length - n-1);
                        string subpstr1 = tempstr.Substring(0,  n )+"?";

        括号优先级处理递归算法(ref subpstr);
                        for (int i = 0; i < subpstr.Length; i++)
                        {
                            if (subpstr[i] == ')')
                            {
                                
                                char[] tempchar = subpstr.ToCharArray();                         
                                                     
                                tempchar[i] = '?';
                                string char2str = "";
                                for (int i1 = 0; i1 < tempchar.Length; i1++)
                                {
                                    char2str += tempchar[i1];
                                }                       
                                tempstr = subpstr1  + char2str;
                              i = subpstr.Length;
                            }
                           
                        }
                    
                    }

    }

    }

    3,需要说明的是,这个递归算法从最内层的括号起,使用两个?代替(),一直到最外层括号,有了这样一个递归顺序,下一步,字符串变操作数和操作符,然后加入运算加减乘除,先消化,这一步下一节讲。

    注,并行的括号处理,这个递归程序一并处理了。先是三个(((,然后处理最后一个),倒数第二个),倒数第三个),处理结束。

    待续(慢慢来!...........)每天一点小改变☺

    我的邮箱liuganggang_1978@163.com;734523623@qq.com

    展开全文
  • 这次安卓开发课程要我们做一个简单的计算器但是要能实现基本的计算功能要比较美观的界面,水平有限只做了一个简单的只能实现带括号的四则运算 界面布局 代码设计 主界面设计(activity_main.xml)代码: <?xml ...

    这次安卓开发课程要我们做一个简单的计算器但是要能实现基本的计算功能要有比较美观的界面,水平有限只做了一个简单的只能实现带括号的四则运算

    界面布局

    计算器的界面

    代码设计

    主界面设计(activity_main.xml)代码:

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        tools:context=".MainActivity">
        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:background="@drawable/background3"/>
        <EditText
            android:id="@+id/edit"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="0"
            android:textColorHint="#3333FF"
            android:textSize="40sp"
            android:textColor="#3333FF"
            android:maxLines="1"
            android:cursorVisible="false"
            android:scrollbars="vertical"
            android:background="@null"
            android:gravity="center_vertical|end"
            android:inputType="textMultiLine"/>
    
        <TextView
            android:id="@+id/ans"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="0"
            android:textColor="#0000CC"
            android:textSize="40sp"
            android:maxLines="1"
            android:layout_below="@id/edit"
            android:layout_marginTop="45dp"
            android:gravity="end"/>
        <LinearLayout
            android:id="@+id/l1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/ans"
            style="@style/greenStyle"
            android:layout_marginTop="45dp">
            <Button
                android:id="@+id/btnClear"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="C"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"/>
            <Button
                android:id="@+id/btn01"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="("
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btnClear"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btn02"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text=")"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn01"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btndiv"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="÷"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#EE0000"
                android:layout_alignLeft="@id/btn02"
                android:layout_marginLeft="5dp"/>
        </LinearLayout>
    
        <LinearLayout
            android:id="@+id/l2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/l1"
            android:layout_marginTop="2dp"
            style="@style/greenStyle">
            <Button
                android:id="@+id/btn7"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="7"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"/>
            <Button
                android:id="@+id/btn8"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="8"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn7"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btn9"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="9"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn8"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btnmulti"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="×"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#EE0000"
                android:layout_alignLeft="@id/btn9"
                android:layout_marginLeft="5dp"/>
        </LinearLayout>
    
        <LinearLayout
            android:id="@+id/l3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/l2"
            android:layout_marginTop="2dp"
            style="@style/greenStyle">
            <Button
                android:id="@+id/btn4"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="4"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"/>
            <Button
                android:id="@+id/btn5"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="5"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn4"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btn6"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="6"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn5"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btnsub"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="-"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#EE0000"
                android:layout_alignLeft="@id/btn6"
                android:layout_marginLeft="5dp"/>
        </LinearLayout>
    
        <LinearLayout
            android:id="@+id/l4"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/l3"
            android:layout_marginTop="2dp"
            style="@style/greenStyle">
            <Button
                android:id="@+id/btn1"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="1"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"/>
            <Button
                android:id="@+id/btn2"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="2"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn1"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btn3"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="3"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn2"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btnadd"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="+"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#EE0000"
                android:layout_alignLeft="@id/btn3"
                android:layout_marginLeft="5dp"/>
        </LinearLayout>
    
        <LinearLayout
            android:id="@+id/l5"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/l4"
            android:layout_marginTop="2dp"
            style="@style/greenStyle">
            <Button
                android:id="@+id/btndel"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="del"
                android:textColor="#FFFFFF"
                android:textAllCaps="false"
                android:textSize="40sp"
                android:background="#00E5EE"/>
            <Button
                android:id="@+id/btn0"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="0"
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btndel"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btnpoint"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="."
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#00E5EE"
                android:layout_alignLeft="@id/btn0"
                android:layout_marginLeft="5dp"/>
            <Button
                android:id="@+id/btnequal"
                android:layout_width="0dp"
                android:layout_height="80dp"
                android:layout_weight="1"
                android:text="="
                android:textColor="#FFFFFF"
                android:textSize="40sp"
                android:background="#EE0000"
                android:layout_alignLeft="@id/btnpoint"
                android:layout_marginLeft="5dp"/>
        </LinearLayout>
    
    </RelativeLayout>
    

    样式界面设计(styles.xml)代码:

    <resources>
    
        <!-- Base application theme. -->
        <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
            <!-- Customize your theme here. -->
            <item name="colorPrimary">@color/colorPrimary</item>
            <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
            <item name="colorAccent">@color/colorAccent</item>
        </style>
        <style name="greenStyle">
            <item name="android:layout_width">wrap_content</item>
            <item name="android:layout_height">wrap_content</item>
            <item name="android:background">#00FF33</item>
        </style>
    </resources>
    

    其中背景图片为
    background3.png
    选用的背景图
    至此界面基本完成

    算法实现

    利用之前数据结构学过的中缀表达式,但是之前是用C++实现的
    核心代码(calcalator.h)如下:

    #pragma once
    #ifndef _Calculator_h
    #define _Calculator_h
    
    #include<iostream>
    #include<assert.h>
    #include<unordered_map>
    #include<cstring>
    #include"stack.h"
    using namespace std;
    
    unordered_map<char, int> isp, icp;  //*****
    Seqstack<char> m;
    
    char c[100], d[100];
    double num[100];
    
    void charToDouble(const char* ch, long double& res)  //把字符串变为浮点数
    {
    	sscanf_s(ch, "%lf", &res);
    }
    
    class Calculator
    {
    private:
    	Seqstack<long double> s;
    	void Addoperator(long double value);  //进操作数栈
    	bool Get2operator(long double &left, long double &right);   //从栈中退出两个操作数
    	void Dooperator(char op);
    public:
    	Calculator(int sz) :s(sz) {}
    	void Run();
    	void Clear();
    };
    
    void Calculator::Dooperator(char op)
    {
    	long double left, right, value; bool result;
    	result = Get2operator(left, right);
    	if (result)
    	{
    		switch (op)
    		{
    		case '+': {value = left + right; /*printf("\n加入栈中的元素为%lf\n", value);*/ s.push(value); break; }
    		case '-': {value = left - right; /*printf("\n加入栈中的元素为%lf\n", value);*/ s.push(value); break; }
    		case '*': {value = left * right; /*printf("\n加入栈中的元素为%lf\n", value);*/ s.push(value); break; }
    		case '/':
    		{
    			if (right == 0) { cout << "Divide by 0!" << endl; Clear(); }
    			else { value = left / right;  /*cout << "加入栈中的元素为" << value << endl;*/ s.push(value); }
    			break;  //****
    		}
    		}
    	}
    	else Clear();   //****
    }
    
    bool Calculator::Get2operator(long double &left, long double &right)
    {
    	if (s.Isempty()) { cout << "缺少右操作数" << endl; return false; }
    	s.pop(right); /*printf("\n右操作数是:%lf\n", right);*/
    	if (s.Isempty()) { cout << "缺少左操作数" << endl; return false; }
    	s.pop(left); /*printf("\n左操作数是:%lf\n", left);*/
    	return true;
    }
    
    void Calculator::Addoperator(long double value)
    {
    	s.push(value);
    }
    
    void Calculator::Run()
    {
    	isp['#'] = icp['#'] = 0; isp['('] = 1; isp['*'] = isp['/'] = isp['%'] = 5; isp['+'] = isp['-'] = 3; isp[')'] = 6;
    	icp['('] = 6; icp['*'] = icp['/'] = icp['%'] = 4; icp['+'] = icp['-'] = 2; icp[')'] = 1;
    	char ch = '#', ch1, op, tag[10000]; int l = 0, i = 0, k = 0, n = 0, w = 0; long double newoperand;
    	m.push(ch); cin.get(ch); tag[w++] = ch; if (ch == '-') { c[l++] = '-'; cin.get(ch); }  //第一个输入是负号 
    	while (!m.Isempty())
    	{
    		if (isdigit(ch) || ch == '.' || (ch == '-' && tag[w - 2] == '(')) { /*cout << ch;*/ c[l++] = ch; cin.get(ch); tag[w++] = ch; }
    		else
    		{
    			c[l++] = ' ';
    			m.gettop(ch1);
    			if (isp[ch1] < icp[ch]) { m.push(ch); cin.get(ch); tag[w++] = ch; }
    			else if (isp[ch1] > icp[ch]) { m.pop(op); /*cout << op;*/ c[l++] = op; }
    			else { m.pop(op); if (op == '(') { cin.get(ch); tag[w++] = ch; } }
    		}
    	}
    	//cout << c << endl;
    	//cout << tag << endl;
    	//for (i = 0; i < l; ++i) { cout << c[i]; } cout << endl;
    	if (c[0] == '-') { d[0] = c[0]; k++; n = 1; }
    	for (i = n; i < l; ++i)
    	{
    		if (isdigit(c[i]) || c[i] == '.' || (c[i] == '-' && isdigit(c[i + 1]))) { d[k++] = c[i]; }
    		if (c[i] == ' ' && isdigit(c[i - 1])) { d[k++] = '\0'; charToDouble(d, newoperand); Addoperator(newoperand); k = 0; }
    		if (c[i] == '+' || (c[i] == '-'&& !isdigit(c[i + 1])) || c[i] == '/' || c[i] == '*') { Dooperator(c[i]); }
    	}
    
    	long double ans;
    	if (s.pop(ans)) { printf("%.8lf\n", ans); }
    }
    
    void Calculator::Clear()
    {
    	s.makeempty();
    }
    
    #endif
    

    将改代码转为java好困难,debug了我一天,去请教大佬,借鉴了他的代码(calculator1.java)

    package y;
    
    import java.util.*;
    
    /**
     * 计算器
     * @author CJH
     */
    public class Calculator1 {
    
        private static final Map<Character, Integer> basic = new HashMap<Character, Integer>();
        static {
            basic.put('-', 1);
            basic.put('+', 1);
            basic.put('*', 2);
            basic.put('/', 2);
            basic.put('(', 0);
            //在运算中  ()的优先级最高,但是此处因程序中需要 故设置为0
        }
    
    
    
        private String toPostfix(String infix){
    
            //定义队列  用于存储 数字  以及最后的  后缀表达式
            List<String> queue = new ArrayList<>();
    
            //定义栈    用于存储  运算符  最后stack中会被 弹空
            List<Character> stack = new ArrayList<>();
    
            //判定标准 将表达式中会出现的运算符写出来
            String standard = "*/+-()";
    
            //对于第一个为负数的进行预处理,例如-3*6 ->(0-3)/*6
            if (infix.charAt(0) == '-'){
                StringBuilder stringBuilder = new StringBuilder(infix);
                stringBuilder.insert(0,"(0");
                int i = 3;
                while(i < stringBuilder.length()){
                    if (standard.indexOf(stringBuilder.charAt(i)) == -1){
                        i++;
                        continue;
                    }else{
                        break;
                    }
                }
                stringBuilder.insert(i,')');
                infix = stringBuilder.toString();
            }
    
            //字符数组  用于拆分数字或符号
            char[] charArr = infix.toCharArray();
    
            //在循环中用来保存 字符数组的当前循环变量的  这里仅仅是初始化一个值  没有意义
            char ch;
    
            //用于记录字符长度 【例如100*2,则记录的len为3 到时候截取字符串的前三位就是数字】
            int len = 0;
    
            //开始迭代
            for (int i = 0; i < charArr.length; i++) {
                //保存当前迭代变量
                ch = charArr[i];
    
                //如果当前变量为 数字
                if(Character.isDigit(ch)) {
                    len++;
                    //如果当前变量为  .  会出现在小数里面
                }else if(ch=='.'){
                    len++;
                    //如果是上面标准中的 任意运算一个符号
                }else if(standard.indexOf(ch) != -1) {
                    //长度也有
                    if(len > 0) {
                        //说明符号之前的可以截取下来做数字
                        queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len, i)));
                        //长度置空
                        len = 0;
                    }
                    //如果是左括号
                    if(ch == '(') {
                        //将左括号 放入栈中
                        stack.add(ch);
                        //跳出本次循环  继续找下一个位置
                        continue;
                    }
                    //如果栈不为empty,
                    if (!stack.isEmpty()) {
                        //获取栈的大小-1  即代表栈最后一个元素的下标
                        int size = stack.size() - 1;
                        //设置标志位
                        boolean flag = false;
                        //若当前ch为右括号,则 栈里元素从栈顶一直弹出,直到弹出到 左括号
                        while (size >= 0 && ch == ')' && stack.get(size) != '(') {
                            //注意此处条件:ch并未入栈,所以并未插入队列中;同样直到找到左括号的时候,循环结束了,所以左括号也不会放入队列中【也就是:后缀表达式中不会出现括号】
                            queue.add(String.valueOf(stack.remove(size)));
                            //size-- 保证下标永远在栈最后一个元素【栈中概念:指针永远指在栈顶元素】
                            size--;
                            //设置标志位为true  表明一直在取()中的元素
                            flag = true;
                        }
                        //若取得不是()内的元素,并且当前栈顶元素的优先级>=对比元素 那就出栈插入队列
                        while (size >= 0 && !flag && basic.get(stack.get(size)) >= basic.get(ch)) {
                            //同样  此处也是remove()方法,既能得到要获取的元素,也能将栈中元素移除掉
                            queue.add(String.valueOf(stack.remove(size)));
                            size--;
                        }
                    }
                    //若当前元素不是右括号
                    if(ch != ')') {
    
                        //就要保证这个符号 入栈
                        stack.add(ch);
                    } else {
                        //否则就要出栈 栈内符号
                        stack.remove(stack.size() - 1);
                    }
                }
                if(i == charArr.length - 1) {
                    //如果已经走到了  中缀表达式的最后一位
                    if(len > 0) {
                        //如果len>0  就截取数字
                        queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len+1, i+1)));
                    }
                    int size = stack.size() - 1;
                    //size表示栈内最后一个元素下标
                    while (size >= 0) {
                        //一直将栈内  符号全部出栈 并且加入队列中  【最终的后缀表达式是存放在队列中的,而栈内最后会被弹空】
                        queue.add(String.valueOf(stack.remove(size)));
                        size--;
                    }
                }
    
            }
            StringBuilder res = new StringBuilder();
            while(!queue.isEmpty()){
                res.append(queue.remove(0));
                res.append(",");
            }
            res.deleteCharAt(res.length()-1);
            return res.toString();
            //将队列中元素以,分割 返回字符串
        }
    
    
        /**
         * 计算
         * @param infix 中缀表达式
         * @return 计算结果
         */
        public String run(String infix) throws ArithmeticException,NullPointerException{
    
            //计算栈
            Stack<Double> stack = new Stack<>();
    
            //转换成后缀表达式
            String postfix = toPostfix(infix);
    
            String[] array = postfix.split(",");
    
            String standard = "*/+-";
            for (String str : array) {
                if (standard.indexOf(str.charAt(0)) != -1) {
                    //进行运算
                    double right = stack.pop();
                    double left = stack.pop();
                    char ch = str.charAt(0);
                    double result=0;
                    switch (ch) {
                        case '+':
                            result = left + right;
                            break;
                        case '-':
                            result = left - right;
                            break;
                        case '*':
                            result = left * right;
                            break;
                        case '/':
                            if (right == 0) {
                                //抛出异常
                                throw new ArithmeticException("被除数不能为0");
                            } else {
                                result = left / right;
                            }
                            break;
                        default:
                            break;
                    }
                    //操作数压栈
                    stack.push(result);
                } else {
                    //操作数压栈
                    stack.push(Double.parseDouble(str));
                }
            }
            java.text.DecimalFormat df = new java.text.DecimalFormat("0.00000000");
            return df.format(stack.pop()).toString();
        }
    
        public static void main(String []args) {
            Scanner sc = new Scanner(System.in);
            String s = sc.next();
            Calculator1 cal = new Calculator1();
            System.out.println(cal.run(s));
        }
    }
    
    

    自己改过来后,java代码如下

    package com.example.calculatorapp;
    
    import android.util.Log;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Stack;
    
    import static java.lang.Character.isDigit;
    
    public class Calculator {
        private Map<Character, Integer> isp = new HashMap<>();
        private Map<Character, Integer> icp = new HashMap<>();
        private Stack<Character> m = new Stack<>();
        private char []c = new char[1000];
        private char []d = new char[1000];
        private Stack<Double> s = new Stack<>();
        private double left, right;
        private int flag = 0;  //除以0的标记
        private double charToDouble(char []ch)  //把字符串变为浮点数
        {
            System.out.print("ch = ");
            for(int i = 0; i < ch.length; ++i) {
                System.out.print(ch[i]);
            }
            System.out.println("ch = " + String.valueOf(ch));
            double res = Double.parseDouble(String.valueOf(ch));
            System.out.println("res = " + res);
            return res;
        }
    
        private void Addoperator(double value) { //进操作数栈
            s.push(value);
        }
    
        private boolean Get2operator() {  //从栈中退出两个操作数
            if (s.empty()) {
                Log.d("输入表达式错误", "缺少右操作数");
                return false;
            }
            right = s.peek();
            s.pop();
            if (s.empty()) {
                Log.d("输入表达式错误", "缺少左操作数");
                return false;
            }
            left = s.peek();
            s.pop();
            return true;
        }
    
        private void Clear()  //清空栈
        {
            while(!s.empty()){ s.pop(); }
        }
    
        private void Dooperator(char op)
        {
            double value;
            boolean result = Get2operator();
            System.out.println("left = " + left);
            System.out.println("right = " + right);
            if (result) {
                switch (op) {
                    case '+': {value = left + right; System.out.println("value = " + value); s.push(value); break; }
                    case '-': {value = left - right; System.out.println("value = " + value); s.push(value); break; }
                    case '*': {value = left * right; System.out.println("value = " + value); s.push(value); break; }
                    case '/':
                    {
                        if (right == 0) { Log.d("除数不可以为0","除数为0");
                            if(left < 0)  { flag = 1; }
                            else if(left > 0) {flag = 2;}
                            else if(left == 0) {flag = 3;}
                            Clear();
                            return;
                        }
                        else { value = left / right; System.out.println("value = " + value); s.push(value); }
                        break;  //****
                    }
                }
            }
            else Clear();   //****
        }
    
        public String Run(String str) {
            flag = 0;
            str += "  ";  //防止后面越界
            int t = 0;
            isp.put('#', 0);
            icp.put('#', 0);
            isp.put('(', 1);
            icp.put('(', 6);
            isp.put('*', 5);
            icp.put('*', 4);
            isp.put('/', 5);
            icp.put('/', 4);
            isp.put('%', 5);
            icp.put('%', 4);
            isp.put('+', 3);
            icp.put('+', 2);
            isp.put('-', 3);
            icp.put('-', 2);
            isp.put(')', 6);
            icp.put(')', 1);
            char ch = '#', ch1, op;
            char[] tag = new char[10000];
            int l = 0, i = 0, k = 0, n = 0, w = 0;
            double newoperand = 0;
            m.push(ch);
            ch = str.charAt(t);
            tag[w++] = ch;
            if (ch == '-') {
                c[l++] = '-';
                t++;
                ch = str.charAt(t);
            }  //第一个输入是负号
            while (!m.empty()) {
                if (isDigit(ch) || ch == '.' || (ch == '-' && tag[w - 2] == '(')) {
                    System.out.println("ch 1 = " + ch);
                    c[l++] = ch;
                    t++;
                    System.out.println("t = " + t);
                    ch = str.charAt(t);
                    System.out.println("ch = " + ch);
                    tag[w++] = ch;
                } else {
                    c[l++] = ' ';
                    ch1 = m.peek();
                    int a = isp.get(ch1);
                    if (!icp.containsKey(ch)) {
                        icp.put(ch, 0);     //*******
                    }
                    int b = icp.get(ch);
                    if (a < b) {
                        m.push(ch);
                        t++;
                        ch = str.charAt(t);
                        tag[w++] = ch;
                    } else if (a > b) {
                        op = m.peek();
                        m.pop();
                        c[l++] = op;
                        System.out.println("op = " + op);
                    } else {
                        op = m.peek();
                        m.pop();
                        if (op == '(') {
                            t++;
                            ch = str.charAt(t);
                            tag[w++] = ch;
                        }
                    }
                }
            }
            System.out.println("c = " + c);
            System.out.println("tag = " + tag);
            for (i = 0; i < l; ++i) { System.out.print(c[i]); }
            System.out.println();
            if (c[0] == '-') {
                d[0] = c[0];
                System.out.print("d = ");
                for(int j = 0; j < d.length; ++j) {
                    System.out.print(d[j]); }
                System.out.println();
                System.out.println("c[0] = " + c[0]);
                k++;
                System.out.println("k = " + k);
                n = 1;
            }
            for (i = n; i < l; ++i) {
                if (isDigit(c[i]) || c[i] == '.' || (c[i] == '-' && isDigit(c[i + 1]))) {
                    d[k++] = c[i];
                    System.out.println("k = " + k);
                    System.out.println("c[i] = " + c[i]);
                    System.out.print("d = ");
                    for(int j = 0; j < d.length; ++j) {
                        System.out.print(d[j]); }
                    System.out.println();}
                if (c[i] == ' ' && (i >= 1 &&isDigit(c[i - 1]))) {
                    System.out.print("d = ");
                    for(int j = 0; j < d.length; ++j) { System.out.print(d[j]); }
                    System.out.println();
                    newoperand = charToDouble(d);  //****
                    Addoperator(newoperand);
                    k = 0;
                    d = new char[1000];
                    System.out.println("k = " + k);
                }
                if (c[i] == '+' || (c[i] == '-' && !isDigit(c[i + 1])) || c[i] == '/' || c[i] == '*') {
                    Dooperator(c[i]);
                    if(flag == 1){ return "-∞"; }
                    if(flag == 2) {return "∞";}
                    if(flag == 3) {return "出错";}
                }
            }
            double ans;
            ans = s.peek();
    //        System.out.println("运算结果为: " + ans);
            java.text.DecimalFormat df = new java.text.DecimalFormat("0.00000000");
    //        System.out.println(df.format(ans).toString());
            return df.format(ans).toString();
        }
    }
    

    安卓主活动(MainActvity.java)代码:

    package com.example.calculatorapp;
    
    import androidx.appcompat.app.AppCompatActivity;
    
    import android.os.Bundle;
    import android.text.InputType;
    import android.view.Gravity;
    import android.view.View;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.TextView;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{
        private Button btn0, btn1, btn2, btn3, btn4, btn5, btn6, btn7, btn8, btn9;
        private Button btn_equal, btn_div, btn_add, btn_sub, btn_multi;
        private Button btn_point, btn01, btn02, btn_clear, btn_delete;
        private TextView textView;
        private EditText editText;
        String rep = "";  //表达式
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            btn0 = (Button) findViewById(R.id.btn0);
            btn1 = (Button) findViewById(R.id.btn1);
            btn2 = (Button) findViewById(R.id.btn2);
            btn3 = (Button) findViewById(R.id.btn3);
            btn4 = (Button) findViewById(R.id.btn4);
            btn5 = (Button) findViewById(R.id.btn5);
            btn6 = (Button) findViewById(R.id.btn6);
            btn7 = (Button) findViewById(R.id.btn7);
            btn8 = (Button) findViewById(R.id.btn8);
            btn9 = (Button) findViewById(R.id.btn9);
            btn_point = (Button) findViewById(R.id.btnpoint);
            btn_add = (Button) findViewById(R.id.btnadd);
            btn_sub = (Button) findViewById(R.id.btnsub);
            btn_div = (Button) findViewById(R.id.btndiv);
            btn_multi = (Button) findViewById(R.id.btnmulti);
            btn_equal = (Button) findViewById(R.id.btnequal);
            btn01 = (Button) findViewById(R.id.btn01);
            btn02 = (Button) findViewById(R.id.btn02);
            btn_clear = (Button) findViewById(R.id.btnClear);
            btn_delete = (Button) findViewById(R.id.btndel);
            textView = (TextView) findViewById(R.id.ans);
            editText = (EditText) findViewById(R.id.edit);
            editText.setKeyListener(null);
            btn0.setOnClickListener(this); //******
            btn1.setOnClickListener(this);
            btn2.setOnClickListener(this);
            btn3.setOnClickListener(this);
            btn4.setOnClickListener(this);
            btn5.setOnClickListener(this);
            btn6.setOnClickListener(this);
            btn7.setOnClickListener(this);
            btn8.setOnClickListener(this);
            btn9.setOnClickListener(this);
            btn01.setOnClickListener(this);
            btn02.setOnClickListener(this);
            btn_delete.setOnClickListener(this);
            btn_clear.setOnClickListener(this);
            btn_equal.setOnClickListener(this);
            btn_sub.setOnClickListener(this);
            btn_add.setOnClickListener(this);
            btn_point.setOnClickListener(this);
            btn_div.setOnClickListener(this);
            btn_multi.setOnClickListener(this);
        }
        @Override
        public void onClick(View v){
            switch(v.getId()) {
                case R.id.btn0:
                    rep += "0";
                    editText.setText(rep);
                    break;
                case R.id.btn1:
                    rep += "1";
                    editText.setText(rep);
                    break;
                case R.id.btn2:
                    rep += "2";
                    editText.setText(rep);
                    break;
                case R.id.btn3:
                    rep += "3";
                    editText.setText(rep);
                    break;
                case R.id.btn4:
                    rep += "4";
                    editText.setText(rep);
                    break;
                case R.id.btn5:
                    rep += "5";
                    editText.setText(rep);
                    break;
                case R.id.btn6:
                    rep += "6";
                    editText.setText(rep);
                    break;
                case R.id.btn7:
                    rep += "7";
                    editText.setText(rep);
                    break;
                case R.id.btn8:
                    rep += "8";
                    editText.setText(rep);
                    break;
                case R.id.btn9:
                    rep += "9";
                    editText.setText(rep);
                    break;
                case R.id.btnadd:
                    rep += "+";
                    editText.setText(rep);
                    break;
                case R.id.btnsub:
                    rep += "-";
                    editText.setText(rep);
                    break;
                case R.id.btndiv:
                    rep += "÷";
                    editText.setText(rep);
                    break;
                case R.id.btnmulti:
                    rep += "×";
                    editText.setText(rep);
                    break;
                case R.id.btn01:
                    rep += "(";
                    editText.setText(rep);
                    break;
                case R.id.btn02:
                    rep += ")";
                    editText.setText(rep);
                    break;
                case R.id.btndel:
                    rep = rep.substring(0, rep.length() - 1);  //*****退格,删除最后一位
                    editText.setText(rep);
                    break;
                case R.id.btnClear:
                    rep = "";  //清空
                    editText.setText(rep);
                    break;
                case R.id.btnpoint:
                    rep += ".";
                    editText.setText(rep);
                    break;
                case R.id.btnequal:
                    editText.setText(rep+"="); //把式子代入
                    Calculator cal = new Calculator();
                    rep = rep.replace('÷', '/'); //记得把运算符换成计算机的符号****
                    rep = rep.replace('×', '*');
                    textView.setText(cal.Run(rep));
                    rep = ""; //清零,重新计算
                    break;
            }
        }
    }
    
    

    至此简单的计算器大功告成啦!

    可是仍然存在诸多不足

    不足:
    (1)界面输入表达式的文本框不能实现自动换行,最多只能显示一行,显示多行的话会打乱当前的界面布局,以我目前的水平无法处理
    (2)答案输出的文本框最多只能输出一行,多出的部分无法显示,若要显示会和(1)一样打乱当前的布局
    (3)算法对许多特殊情况无法做出好的处理,只能对除以0的情况加以处理:
    左边的数大于0,输出∞,小于0输出-∞,等于0输出“出错”
    但是如果输入表达式的格式出错,app会自动结束退出,必须要求输入的格式不能错
    (4)只能计算简单的带括号的四则运算,对log、exp、取模等较高级的运算无法实现

    今后希望能进一步改进不足之处:
    (1)完善界面,使之更加美观
    (2)改进算法,用更完善的算法对各种不合理的情况加以妥善处理,并进一步实现高级的运算
    (3)使文本框能输入多行并自动换行,显示最后输入的部分,输出框能尽量显示全部的结果,用多行显示,实在不行一部分再用省略号代替

    展开全文
  • c#实战 计算器(支持加减乘除括号的混合计算)

    万次阅读 多人点赞 2018-09-17 23:57:18
    看懂代码的重要前提是你一定的算法基础(前缀、中缀、后缀表达式)和数据结构基础(链表、栈)。 当初写这份代码的时候还是小白,随着对C#的深入学习,个人觉得本文代码还有很多可以优化的地方,如果觉得low的话...
  • 括号带键盘输入事件的计算器

    千次阅读 2015-05-07 20:00:50
    java一个计算器的作业,还是不够完善可能bug,框架和键盘输入那些是自己写计算器的核心算法是朋友给,http://my.csdn.net/qdbszsj,采用对String递归算法,结果都是对,搞了好久,感觉自己好渣
  • java老师布置作业,要我们编个计算器,而且要有括号功能。。。编恶心哪,600多行代码,调试来调试去终于能用了,但是估计还有bug。 有一个bug我自己知道,但是不影响正常使用:可以存在前导零,就是说可以有0087...
  • 用 BeanShell来解析有算法优先级以及带括号,程序精炼转发分享供大家学习。
  • Python开发——利用正则表达式实现计算器算法(1)不使用eval()等系统自带计算方法(2)实现四则混合运算、括号优先级解析思路:1、字符串预处理,将所有空格去除2、判断是否存在括号运算,若存在进行第3步,若不存在...
  • 用户输入一长串表达式,里面有数字,有加减乘除符号,有括号,首先我们应该把用户输入表达式记录下来,并进行适当划分,将数字和符号分开来,为后续计算做准备 首先我们在为每个按钮都设置一个data-value...
  • 主要以下功能:可以连续计算四则运算,可以自己分辨多位数,小数,负数。 后续会加入sin(),cos()等。(已经加入sin,cos,tan,次方pow,阶乘! ,开平方sqrt,取对数log) 主要原理: 建立两个栈,一个用于存放...
  • Python开发——利用正则表达式实现计算器算法  (1)不使用eval()等系统自带计算方法  (2)实现四则混合运算、括号优先级解析 思路:  1、字符串预处理,将所有空格去除  2、判断是否存在括号运算,若...
  • 看懂代码的重要前提是你一定的算法基础 前缀、中缀、后缀表达式 和数据结构基础 链表、栈 。 当初写这份代码c#计算器,支持+-*/()的混合运算,对负号不支持.原理:将点击的按钮赋给inputStr,然后对inputStr分析、...
  •  3、利用正则表达式获取最底层括号四则运算表达式  4、将四则运算表达式进行预处理:表达式开头负数时,在表达式前加上一个0  5、利用re.split()、re.findall()方法,通过加减符号,对四则运算进行拆分为...
  • 对于任意字符串,包含+ - * /和括号, 求出该表达式值 首先百度该问题,网上不少答案,但是实际思考,发现,很多答案没有考虑完全,例如: -1+(-2)*3 遇到负号怎么办? 现贴出代码如下: 1 package ...
  • 如果只是为了完成简单的单步加减乘除运算,我相信对大家来说都没有什么难度,但是实现带括号的四则运算功能,编程就会发现还是比较难度,所以这里我分享一下我以前写过的这个算法。 这里的实现算法已经被模块化为...
  • 计算器项目

    千次阅读 2021-01-23 17:12:20
    项目简介 本项目目的是写一个计算器项目,主要考察...第二个是四则计算器,涉及到带优先级的运算,能够实现一个带括号的四则表达式的运算;第三个是科学计算器,就是在四则计算器的基础上添加了三角、反三角、指数
  • 前辈(波兰一位科学家)在计算带有括号的四则表达式,利用逆波兰算法(后缀表达法)。简直神了!!其实代码code并不难,难的是算法的指导,要先理解算法,才能编码。 <?php $num_arr = array();// 声明数字栈 $...
  • 搜索和删除括号的算法是从头开始创建的但是对于字符串解析,我们在jasvascript中使用eval方法 先决条件 首先需要在系统中安装带npm的节点版本3.x(可以使用最新版本) 正在安装 ****快速运行 1-需要首先在系统中...
  • Python开发——利用正则表达式实现计算器算法(1)不使用eval()等系统自带计算方法(2)实现四则混合运算、括号优先级解析思路: 1、字符串预处理,将所有空格去除 2、判断是否存在括号运算,若存在进行第3步,若...
  • 分数计算器

    2020-10-25 21:07:37
    灰常年(sha)轻(bi)的算法竞赛选手,没写过OOP,于是这次乱写了一同也不知道算不算OOP…… 计算器支持小数,分数。注意我的计算机里面存在一个瑕疵,就是前置符号的优先级比括号和冥还要高,所以形如-3^2,-(5+2*8)...
  • 用java语言实现一个简单计算器,支持加减乘除,小数,带括号运算,不支持负数,该程序带界面,附带使用方法,算法实现简单,可能一些小bug未解决,主要是测试有限。。
  • Qt计算器的实现,支持四则运算,四则运算转换成后缀表达式计算,包含括号匹配算法,判断四则计算中是否有括号且是否左右括号成对出现,没有括号或者有成对出现左右括号则返回值为真,括号不成对出现则返回值为假
  • 简单计算器的C++实现

    2013-05-26 21:14:55
    主要算法需要把我们习惯中序换成后序,这样能够消除小括号,后序排序后就非常好处理了。 另外输入时若空格会出问题,不知道为什么,望C++大神能够解答。 #include #include #include using namespace std...
  • php实现一个简单的四则运算计算器(还不支持... 前辈(波兰一位科学家)在计算带有括号的四则表达式,利用逆波兰算法(后缀表达法)。简直神了!!其实代码code并不难,难的是算法的指导,要先理解算法,才能编码。...
  • (不喜欢看文字描述,可以直接看代码,代码每一步都相应注解,建议代码结合思路分析一块看,可以快速了解转换整个过程) 中缀表达式转后缀表达式思路步骤分析:** 初始化两个栈:运算符栈s1和储存中间结果...
  • 本文主要介绍了PHP实现的简单四则运算计算器功能,结合实例形式分析了...前辈(波兰一位科学家)在计算带有括号的四则表达式,利用逆波兰算法(后缀表达法)。简直神了!!其实代码code并不难,难的是算法的指导,要先理...
  • 本文实例讲述了PHP实现的简单四则运算计算器功能。分享给大家供大家参考,具体如下:php实现一个简单的四...前辈(波兰一位科学家)在计算带有括号的四则表达式,利用逆波兰算法(后缀表达法)。简直神了!!其实代码cod...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

计算器有括号的算法