Question

C++

•Write a program that evaluates a postfix expression (assume it’s valid) such as

6 2 + 5 * 8 4 / -

•The program should read a postfix expression consisting of digits and operators into a string.

•The algorithm is as follows:

1.While you have not reached the end of the string, read the expression from left to right.

–If the current character is a digit, Push its integer value onto the stack (the integer value of a digit character is its value in the computer’s character set minus the value of '0' in the computer’s character set).

–Otherwise, if the current character is an operator, Pop the two top elements of the stack into variables x and y.

–Calculate y operator x.

–Push the result of the calculation onto the stack.

2.When you reach the end of the string, pop the top value of the stack. This is the result of the postfix expression.

–[Example: In Step 2 above, if the operator is '/', the top of the stack is 2 and the next element in the stack is 8, then pop 2 into x, pop 8 into y, evaluate 8 / 2 and push the result, 4, back onto the stack. This note also applies to operator '–'.]

–The arithmetic operations allowed in an expression are

•+ addition

•– subtraction

•* multiplication

•/ division

•^ exponentiation

•% modulus

•[Note: We assume left-to-right associativity for all operators for the purpose of this exercise.] The stack should be maintained with stack nodes that contain an int data member and a pointer to the next stack node. You may want to provide the following functional capabilities:

a.function evaluatePostfixExpression that evaluates the postfix expression

b.function calculate that evaluates the expression (op1 operator op2)

c.function push that pushes a value onto the stack

d.function pop that pops a value off the stack

e.function isEmpty that determines if the stack is empty

f.function printStack that prints the stack

SAMPLE OUTPUT:

INPUT POSTFIX NOTATION: 23+2*

INFIX NOTATION: (2+3)*2

RESULT: 10

Answer 1

#include <iostream>
#include <string.h>

using namespace std;

//declaring Stack
struct Stack
{
   int top;
   unsigned capacity;
   int* array;
};

// Stack Operations
struct Stack* createStack( unsigned capacity )
{
   struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));

   if (!stack) return NULL;

   stack->top = -1;
   stack->capacity = capacity;
   stack->array = (int*) malloc(stack->capacity * sizeof(int));

   if (!stack->array) return NULL;

   return stack;
}
// isEmpty function
int isEmpty(struct Stack* stack)
{
   return stack->top == -1 ;
}
// peek function
char peek(struct Stack* stack)
{
   return stack->array[stack->top];
}
// pop function
char pop(struct Stack* stack)
{
   if (!isEmpty(stack))
       return stack->array[stack->top--] ;
   return '$';
}
// push function
void push(struct Stack* stack, char op)
{
   stack->array[++stack->top] = op;
}

// The evaluatePostfix function which returns value of The postfix expression
int evaluatePostfix(char* exp)
{
   // Create a stack of capacity equal to expression size
   struct Stack* stack = createStack(strlen(exp));
   int i;

   // to check either stack is created or not
   if (!stack) return -1;

   // for scanning each character
   for (i = 0; exp[i]; ++i)
   {
       // If the scanned character is a number push it to the stack.
       if (isdigit(exp[i]))
           push(stack, exp[i] - '0');

       // If the scanned character is an operator, pop two
       // elements from stack apply the operator
       else
       {
           int val1 = pop(stack);
           int val2 = pop(stack);
           switch (exp[i])
           {
           case '+': push(stack, val2 + val1); break;
           case '-': push(stack, val2 - val1); break;
           case '*': push(stack, val2 * val1); break;
           case '/': push(stack, val2/val1); break;
           }
       }
   }
   return pop(stack);
}

// Driver program
int main()
{
   char exp[50];
   cin >> exp;
   cout<<"postfix evaluation: "<< evaluatePostfix(exp);
   return 0;
}
// this program is valid only right postfix expressions,in case expression is wrong it will not work correctly