`
cary
  • 浏览: 85592 次
  • 性别: Icon_minigender_1
  • 来自: 合肥
社区版块
存档分类
最新评论

逆波兰式计算

    博客分类:
  • J2EE
阅读更多
下面的逆波兰式,不支持单目运算,以及{}、〔〕这两类的括号运算。对精度提供了设置,根据你输入的浮点数的小数位的位数来适应,返回和操作数相同位数的结果。由于写的匆忙,好存在很多缺陷。不足的地方希望能给出批评。
java 代码
 
  1. 1.stack.java  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. /** 
  6.  * @author 
  7.  * 
  8.  * @2007-2-8 
  9.  * @to-Email 
  10.  */  
  11. public class Stack {  
  12.   
  13.     private LinkedList stack = new LinkedList();  
  14.     private int top = -1;  
  15.      
  16.     public void push(Object obj)  
  17.     {  
  18.         top++;  
  19.         stack.addFirst(obj);  
  20.     }  
  21.      
  22.     public Object pop()  
  23.     {  
  24.         Object obj = stack.getFirst();  
  25.         top--;  
  26.         stack.removeFirst();  
  27.         return obj;  
  28.     }  
  29.      
  30.     public Object top()  
  31.     {  
  32.         return stack.getFirst();  
  33.     }  
  34.      
  35.     public boolean isEmpty()  
  36.     {  
  37.         if(top == -1 || stack.size() == 0)  
  38.             return true;  
  39.         else  
  40.             return false;  
  41.     }  
  42. }  


2.将输入的表达式转换成逆波兰式
java 代码
 
  1. package structure;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.StringTokenizer;  
  6.   
  7. /** 
  8.  * @author wei 
  9.  *  
  10.  * @2007-2-8 
  11.  * @to-Email 
  12.  */  
  13. public class Calculate {  
  14.   
  15.     private List expression = new ArrayList();  
  16.     private List operator = new ArrayList();  
  17.     private Stack stack;  
  18.       
  19.     public Calculate(String input)  
  20.     {  
  21.         stack = new Stack();  
  22.         StringTokenizer st = new StringTokenizer(input, "+-*/()"true);  
  23.         while (st.hasMoreElements()) {  
  24.             expression.add(st.nextToken());  
  25.         }  
  26.     }  
  27.       
  28.     public static boolean isOperator(String operator) {  
  29.         if ("+".equals(operator) || "-".equals(operator)  
  30.                 || "*".equals(operator) || "/".equals(operator)  
  31.                 || "(".equals(operator) || ")".equals(operator))  
  32.             return true;  
  33.         else  
  34.             return false;  
  35.     }  
  36.       
  37.     public List doTrans()  
  38.     {  
  39.         for(int i = 0;i
  40.         {  
  41.             String str = (String)expression.get(i);  
  42.               
  43.             if(str.equals("+") || str.equals("-"))  
  44.             {  
  45.                 gotOper(str,1);  
  46.             }else if(str.equals("*") || str.equals("/"))  
  47.             {  
  48.                 gotOper(str,2);  
  49.             }else if(str.equals("("))  
  50.             {  
  51.                 stack.push("(");  
  52.             }else if(str.equals(")"))  
  53.             {  
  54.                 gotParen(str);  
  55.             }else  
  56.             {  
  57.                 operator.add(str);  
  58.             }  
  59.         }  
  60.           
  61.         while(!stack.isEmpty())  
  62.         {  
  63.             operator.add(stack.pop());  
  64.         }  
  65.         return operator;  
  66.     }  
  67.       
  68.     public void gotOper(String opThis, int prec1) { // got operator from input  
  69.         while (!stack.isEmpty()) {  
  70.             String opTop = (String) stack.pop();  
  71.             if (opTop.equals("(")) // if it's a '('  
  72.             {  
  73.                 stack.push(opTop); // restore '('  
  74.                 break;  
  75.             } else // it's an operator  
  76.             {  
  77.                 int prec2; // precedence of new op  
  78.   
  79.                 if (opTop.equals("+")  || opTop.equals("-")) // find new op prec  
  80.                     prec2 = 1;  
  81.                 else  
  82.                     prec2 = 2;  
  83.                 if (prec2 < prec1) // if prec of new op less  
  84.                 { // than prec of old  
  85.                     stack.push(opTop); // save newly-popped op  
  86.                     break;  
  87.                 } else  
  88.                     // prec of new not less  
  89.                     //output = output + opTop;  
  90.                     operator.add(opTop);// than prec of old  
  91.             } // end else (it's an operator)  
  92.         } // end while  
  93.         stack.push(opThis); // push new operator  
  94.     }   
  95.   
  96.     public void gotParen(String ch) { // got right paren from input  
  97.         while (!stack.isEmpty()) {  
  98.             String chx = (String)stack.pop();  
  99.             if (chx.equals("(")) // if popped '('  
  100.                 break// we're done  
  101.             else  
  102. //              output = output + chx; // output it  
  103.             operator.add(chx);  
  104.         }   
  105.     }   
  106.       
  107.       
  108.     public static void main(String[] args)  
  109.     {  
  110.         Calculate calculate = new Calculate("2+(4-3)*2");  
  111.         List result = calculate.doTrans();  
  112.           
  113.         for(int i=0;i
  114.         {  
  115.             System.out.println(result.get(i));  
  116.         }  
  117.     }  
  118. }  

3.后序表达式计算
java 代码
 
  1. package structure;  
  2.   
  3. import java.math.BigDecimal;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. /** 
  8.  * @author  
  9.  * 
  10.  * @2007-2-8 
  11.  * @to-Email 
  12.  */  
  13. public class PostControl {  
  14.   
  15.     private List operator = new ArrayList();  
  16.     private Stack stack = new Stack();  
  17.       
  18.     public PostControl(List list)  
  19.     {  
  20.         operator = list;  
  21.     }  
  22.       
  23.     public String doParse()  
  24.     {  
  25.         BigDecimal z = new BigDecimal("0.00");  
  26.         for(int i= 0;i
  27.         {  
  28.             String str = (String)operator.get(i);  
  29.               
  30.             if(!isOperator(str))  
  31.             {   stack.push(str);}  
  32.             else  
  33.             {  
  34.                 BigDecimal y = new BigDecimal((String)stack.pop());  
  35.                 BigDecimal x =new BigDecimal((String)stack.pop());  
  36.                   
  37.                 if(str.equals("+"))  
  38.                 {  
  39.                     z = x.add(y);  
  40.                 }else if(str.equals("-"))  
  41.                 {  
  42.                     z= x.subtract(y);  
  43.                 }else if(str.equals("*"))  
  44.                 {  
  45.                     z = x.multiply(y);  
  46.                 }else if(str.equals("/"))  
  47.                 {  
  48.                     z = x.divide(y);  
  49.                 }else  
  50.                 {  
  51.                     z= new BigDecimal("0.00");  
  52.                 }  
  53.                   
  54.                 stack.push(String.valueOf(z));  
  55.             }  
  56.         }  
  57.         return (String)stack.pop();  
  58.     }  
  59.       
  60.       
  61.     public static boolean isOperator(String operator) {  
  62.         if ("+".equals(operator) || "-".equals(operator)  
  63.                 || "*".equals(operator) || "/".equals(operator)  
  64.                 || "(".equals(operator) || ")".equals(operator))  
  65.             return true;  
  66.         else  
  67.             return false;  
  68.     }  
  69.       
  70.       
  71.     public static void main(String[] args)  
  72.     {  
  73.         Calculate calculate = new Calculate("2+((4.5-3)*2+3)*2");  
  74.         List result = calculate.doTrans();  
  75.           
  76.         PostControl p = new PostControl(result);  
  77.         System.out.println(p.doParse());  
  78.     }  
  79. }  
分享到:
评论

相关推荐

    逆波兰式计算函数多项式

    逆波兰式计算的关键在于,它不需要括号或运算符优先级规则。在正向波兰式(中缀表达式)中,如 `3 + 4 * x`,解析器需要理解乘法先于加法进行。而在逆波兰式中,这个表达式会被转换为 `3 4 x * +`,使得计算顺序直观...

    1. 实验3 逆波兰式的产生及计算-预习提示1

    3. **逆波兰式计算**: 计算逆波兰式时,同样使用栈,但这次栈中存储的是运算对象。扫描逆波兰式,遇到数字则入栈,遇到运算符则取出栈顶的两个运算对象进行运算,将结果入栈。对于一目运算符,只取出栈顶一个运算...

    利用逆波兰式计算表达式

    利用逆波兰式计算表达式,例如 1+3*4 ; (1+5)/6

    后缀逆波兰式代码

    后缀逆波兰式计算是一种常见的数据结构编程技术,旨在解决中序表达式的计算问题。该设计报告将详细介绍后缀逆波兰式计算的设计思路、实现方法和代码实现细节。 一、设计思路 后缀逆波兰式计算的设计思路是将中序...

    java 逆波兰式(这个是java版的还附有实验报告)

    在Java编程语言中,实现逆波兰式计算通常包括以下几个步骤: 1. **表达式解析**:首先,我们需要将常规的中缀表达式(例如 "2 + 3 * 4")转换为逆波兰式("2 3 4 *")。这涉及到运算符优先级和括号处理。可以使用...

    编译原理实验报告6-逆波兰式的翻译和计算.doc

    逆波兰式,又称后缀表达式,是一种在计算表达式时可以避免使用括号的表示方式。它将运算符放在操作数之后,使得表达式的计算可以通过栈的数据结构来简化。在编译原理中,逆波兰式的应用主要是进行语法分析和中间代码...

    逆波兰式计算,将格式化数组转化为逆波兰表达式,a为输入的数组,n为其长度,p为输出逆波兰表达式的目标

    逆波兰式计算,将格式化数组转化为逆波兰表达式,a为输入的数组,n为其长度,p为输出逆波兰表达式的目标,m记录逆波兰表达式的长度.zip

    逆波兰式计算,将格式化数组转化为逆波兰表达式,a为输入的数组,n为其长度

    逆波兰式计算,将格式化数组转化为逆波兰表达式,a为输入的数组,n为其长度,p为输出逆波兰表达式的目标,m记录逆波兰表达式的长度.zip

    用MFC写的逆波兰式计算器

    6. **算法实现**:逆波兰式计算的核心算法包括将表达式分解为数字和操作符,将数字压栈,遇到操作符时弹出栈顶的两个元素进行运算。这个过程需要考虑到操作符的优先级和结合性。 7. **错误处理**:在实际应用中,...

    编译原理逆波兰式分析法源码

    逆波兰式,又称后缀表达式,是一种在编译原理中常见的表示数学计算的表示法。它是由波兰逻辑学家Jan Łukasiewicz提出的一种无括号的表达方式,通过运算符位于操作数之后的方式来避免括号的使用,从而简化表达式解析...

    C逆波兰式(是用c实现的)

    逆波兰式计算相对简单,只需要从左至右扫描逆波兰式,遇到数字则压入栈中,遇到操作符则从栈中弹出两个操作数进行运算,将结果再次压入栈中。最终,栈顶元素即为整个表达式的计算结果。 #### 四、逆波兰式的优势 ...

    编译原理 逆波兰式 C++实现

    C++实现逆波兰式计算的关键在于理解和正确实现栈的数据结构,以及理解运算符的优先级和结合性规则。 总结一下,本主题涵盖了编译原理中的一个重要概念——逆波兰式,以及如何用C++实现中缀表达式到逆波兰式的转换和...

    数据结构--求逆波兰式

    在C语言中实现逆波兰式计算,我们需要以下步骤: 1. 定义栈结构:可以使用数组或链表作为栈的底层实现。这里我们选择数组,因为它更简单且内存管理相对固定。 ```c #define MAX_SIZE 100 typedef char Operator; ...

    逆波兰式(JAVA版)

    - **栈实现**:Java中的`java.util.Stack`类可以方便地实现逆波兰式计算所需的数据结构。 - **解析表达式**:可以使用正则表达式或者自定义解析函数来处理输入的中缀表达式,将其转换为逆波兰式。 - **运算符...

    C++编写的逆波兰式

    这些操作是实现逆波兰式计算的关键。 接下来是"逆波兰式.cpp"。在这个文件中,通常会包含读取逆波兰式表达式的函数,将表达式拆分成操作数和运算符,然后使用栈来逐步计算结果。这个过程分为两个主要步骤:扫描输入...

    逆波兰式的生成-(代码+原理图)

    通过该实验,我们掌握了逆波兰式的原理和实现方法,并且能够将算术表达式转换为逆波兰式,并计算用逆波兰式表示的算术表达式的值。 逆波兰式的生成步骤包括: 1. 在表达式字符串的末尾加一个代表结束的辅助符,...

    逆波兰式的生成与计算

    主要进行逆波兰式的 读取输入和相关计算,经反复测试后代码可用

Global site tag (gtag.js) - Google Analytics