Question

Please make sure that these infix and postfix equations have these answers nothing else:

Infix:

(3 * 4 - (2 + 5)) * 4 / 2 = valid expression

10 + 6 * 11 -(3 * 2 + 14) / 2 = valid expression

Postfix:

9 3 / 6 / 4 * 10 - = -8

9 3 / 6 / 4 * -10 - = 12

(a) Using java.util.stack to write a java program to validate and calculate the result of each arithmetic Expression from input file (infix.dat). All equations from the input file are in traditional infix notation. Display each expression first. Then, if the arithmetic expression is not valid, display “Invalid expression ” message otherwise display the result of the calculation.

(b) Using java.util.Stack and java.util.StringTokenizer to write a java program to validate and calculate postfix expression from the input data file - postfix.dat

infix.dat

5 * 6 + 4
3 - 2 +
( 3 * 4 - (2 + 5)) * 4 / 2
10 + 6 * 11 -(3 * 2 + 14) / 2
2 * (12 + (3 + 5 ) * 2

postfix.dat

5 2 + 8 5 - *
2 4 - 5 2 * +
5 2 6 3 - * + 4 + 2 3 1 + * 7
5 0 /
9 3 / 6 / 4 * 10 - 3 / +
9 3 / 6 / 4 * 10 -
5 2 6 3 - * + 4 + 2 3 1 + * 7 - *
9 3 / 6 / 4 * -10 -

Answer 1

A Java program to evaluate an infix expression:

import java.util.Stack;

public class EvaluateString
{
public static int evaluate(String expression)
{
char[] tokens = expression.toCharArray();

Stack<Integer> values = new Stack<Integer>();

Stack<Character> ops = new Stack<Character>();

for (int i = 0; i < tokens.length; i++)
{
if (tokens[i] == ' ')
continue;

if (tokens[i] >= '0' && tokens[i] <= '9')
{
StringBuffer sbuf = new StringBuffer();

while (i < tokens.length && tokens[i] >= '0' && tokens[i] <= '9')
sbuf.append(tokens[i++]);
values.push(Integer.parseInt(sbuf.toString()));
}

else if (tokens[i] == '(')
ops.push(tokens[i]);

else if (tokens[i] == ')')
{
while (ops.peek() != '(')
values.push(applyOp(ops.pop(), values.pop(), values.pop()));
ops.pop();
}

else if (tokens[i] == '+' || tokens[i] == '-' ||
tokens[i] == '*' || tokens[i] == '/')
{

while (!ops.empty() && hasPrecedence(tokens[i], ops.peek()))
values.push(applyOp(ops.pop(), values.pop(), values.pop()));

ops.push(tokens[i]);
}
}


while (!ops.empty())
values.push(applyOp(ops.pop(), values.pop(), values.pop()));

  
return values.pop();
}

  
public static boolean hasPrecedence(char op1, char op2)
{
if (op2 == '(' || op2 == ')')
return false;
if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-'))
return false;
else
return true;
}


public static int applyOp(char op, int b, int a)
{
switch (op)
{
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
if (b == 0)
throw new UnsupportedOperationException("Cannot divide by zero");
return a / b;
}
return 0;
}

A Java program to evaluate an postfix expression :

public static int postfixEvaluate(String exp) {
                Stack<Integer> s = new Stack<Integer> ();
                Scanner tokens = new Scanner(exp);
                
                while (tokens.hasNext()) {
                        if (tokens.hasNextInt()) {
                                s.push(tokens.nextInt());
                        } else {
                                int num2 = s.pop();
                                int num1 = s.pop();
                                String op = tokens.next();
                                
                                if (op.equals("+")) {
                                        s.push(num1 + num2);
                                } else if (op.equals("-")) {
                                        s.push(num1 - num2);
                                } else if (op.equals("*")) {
                                        s.push(num1 * num2);
                                } else {
                                        s.push(num1 / num2);
                                }
                                
                        }
                }
                return s.pop();
    }