Question

For this assignment, you are to write a program, which will calculate the results of Reverse Polish expressions that are provided by the user.

You must use a linked list to maintain the stack for this program.

You must handle the following situations (errors):
Too many operators (+ - / *)
Too many operands (doubles)
Division by zero

The program will take in a Polish expression that separates the operators and operands by a single space, and terminates the expression with an equals sign.

The program will continue to take and evaluate expressions until the user enters a zero (0) on a line by itself followed by a new line.

Your sample output should show the handling of all the error conditions as well as make use of all of the operators.

Sample IO: (note: formatting of output isn’t a critical issue but proper input processing is essential)
Input Output
10 15 + = 25
10 15 - = -5
2.5 3.5 + = 6 (or 6.0)
10 0 / = Error: Division by zero
10 20 * / = Error: Too many operators
12 20 30 / = Error: Too many operands
-10 -30 - = 20
100 10 50 25 / * - -2 / = -40

NO ARRAYS

NO LIBRARIES (just <iostream>)

Answer 1

#include<iostream>
#include<sstream>
using namespace std;

struct node
{
   double data;
   struct node *next;
};

class Stack
{
   private:
       struct node *top;
       double size;
   public:
       Stack()
       {
           top=NULL;
           size=0;
       }
       void push(double val);
       bool pop();
       bool isEmpty();
       double topOfStack();
       double sizeOfStack();
};

void Stack::push(double val)
{
   //Increment size by 1
   size++;

   //create new Node
   struct node *newNode=new node;
   newNode->data=val;
   newNode->next=NULL;

   //Append to front of list
   newNode->next=top;
   top=newNode;
}

bool Stack::pop()
{
   //If stack empty
   if(isEmpty())
   {
       return false;
   }
   //Decrement size by 1
   size--;
   //Delete top
   struct node *temp=top;
   top=top->next;
   free(temp);
   return true;
}

bool Stack::isEmpty()
{
   return top==NULL;
}

double Stack::topOfStack()
{
   //If stack is not empty
   if(!isEmpty())
   {
       return top->data;
   }
   return -9999;
}

double Stack::sizeOfStack()
{
   return size;
}

bool evaluateExpression(string expr, double *result)
{
   Stack s;
   double x,y;
   string word;
   // to split the strng with respect to white spaces
   istringstream ss(expr);
   do
   {
       //store each word
       ss >> word;
       //If word is = then stop
       if(word=="=")
       {
           break;
       }

       //If operatos
       if(word=="+" || word=="-" || word=="*" || word=="/")
       {
           if(s.isEmpty())
           {
               cout<<"Error: Too many operators"<<endl;
               return false;
           }
            y=s.topOfStack();
            s.pop();
            if(s.isEmpty())
           {
               cout<<"Error: Too many operators"<<endl;
               return false;
           }
            x=s.topOfStack();
            s.pop();
            switch(word[0])
            {
                case '+':
                       s.push(x+y);
                       break;
                case '-':
                       s.push(x-y);
                       break;
                case '*':
                       s.push(x*y);
                       break;
                case '/':
                       if(y==0)
                       {
                           cout<<"Error: Division by zero"<<endl;
                           return false;
                       }
                       s.push(x/y);
                       break;
            }  
       }
       else
       {
           //stod() is to convert string to double
           s.push(stod(word));
       }
    }while(ss);
  
    //If more operands left
    if(s.sizeOfStack()>1)
    {
       cout<<"Error: Too many operands"<<endl;
       return false;
    }
    //Store top of stack into result variable
    *result=s.topOfStack();
    return true;
}

int main()
{
   Stack s;
   string expr;
   double result=0;
   while(true)
   {
       getline(cin,expr);
       //If user enters zero then break the loop
       if(expr=="zero")
       {
           break;
       }
       cout<<expr<<" ";
       //If expression is valid then print output
       //value of expresion stores in result since we passed address of result
       if(evaluateExpression(expr,&result))
       {
           cout<<result<<endl;
       }
   }
   return 0;
}

output screenshot:

C:\Users\srini\Desktop>g++ postfixEvaluation.cpp C:\Users\srini Desktop>a.exe 10 15 + = 110 15 + = 25 10 15 - = 110 15 - = 2.5 3.5 + = 2.5 3.5 + = 6 10 0 / = 10 0 / = Error: Division by zero 10 20 * 7 = 10 20 * 7 = Error: Too many operators 12 20 30 / = 12 20 30 / = Error: Too many operands -10 -30 - = -10 -30 - = 20 100 10 50 25 / * - -2 / = 100 10 50 25 / * - -2 / = -40 zero C:\Users\srini\Desktop>