Question

C++ Stack Program

Write a program that uses stacks to evaluate an arithmetic expression in infix notation. The program should NOT convert the infix to postfix and then evaluate the postfix.

The program takes as input a numeric expression in infix notation, such as 3+4*2, and outputs the result.

1a)   Operators are +, -, *, /

1b) Assume that the expression is formed correctly so that each operation has two arguments.

1c) The expression can have parenthesis, for example: 3*(4-2)+6

1d) The expression can have negative numbers.

1e) The expression can have spaces in it, for example: 3 * (4-2) +6

Here are some useful functions that you may need:

               char cin.peek(); -- returns the next character of the cin input stream ( without reading it)

               bool isdigit(char c); -- returns true if c is one of the digits ‘0’ through ‘9’, false otherwise

               cin.ignore(); -- reads and discards the next character from the cin input stream

               cin.get(char &c); -- reads a character in c ( could be a space or the new line )

Test your program with a variety of arithmetic expressions.

Answer 1

#include <bits/stdc++.h>

using namespace std;

// Function to find precedence of

// operators.

int precedence(char op){

    if(op == '+'||op == '-')

    return 1;

    if(op == '*'||op == '/')

    return 2;

    return 0;

}

// Function to perform arithmetic operations.

int applyOp(int a, int b, char op){

    switch(op){

        case '+': return a + b;

        case '-': return a - b;

        case '*': return a * b;

        case '/': return a / b;

    }

    return 0;

}

// Function that returns value of

// expression after evaluation.

int evaluate(string input){

    int i;

    

    // stack to store integer values.

    stack <int> values;

    

    // stack to store operators.

    stack <char> ops;

    char prev='#';

    for(i = 0; i < input.length(); i++){

        

        // Current token is a whitespace,

        // skip it.

        if(input[i] == ' ')

            continue;

        

        // Current token is an opening

        // brace, push it to 'ops'

        else if(input[i] == '('){

            prev='(';

            ops.push(input[i]);

        }

        

        // Current token is a number, push

        // it to stack for numbers.

        else if(isdigit(input[i])){

            prev='1';

            int val = 0;

            

            // There may be more than one

            // digits in number.

            while(i < input.length() &&

                        isdigit(input[i]))

            {

                val = (val*10) + (input[i]-'0');

                i++;

            }

            i--;

            values.push(val);

        }

        

        // Closing brace encountered, solve

        // entire brace.

        else if(input[i] == ')')

        {

            prev=')';

            while(!ops.empty() && ops.top() != '(')

            {

                int val2 = values.top();

                values.pop();

                

                int val1 = values.top();

                values.pop();

                

                char op = ops.top();

                ops.pop();

                

                values.push(applyOp(val1, val2, op));

            }

            

            // pop opening brace.

            if(!ops.empty())

            ops.pop();

        }

        // if starting number is negative

        else if(input[i]=='-' && prev=='#')   {

             int num=-1;

             i++;

             int val = 0;

            

            // There may be more than one

            // digits in number.

            while(i < input.length() &&

                        isdigit(input[i]))

            {

                val = (val*10) + (input[i]-'0');

                i++;

            }

            i--;

            val=val*num;

            

            values.push(val);

        }

        // starting number after an opening bracket is negative

        else if(input[i]=='-' && prev=='(')   {

               int num=-1;

             i++;

             int val = 0;

            

            // There may be more than one

            // digits in number.

            while(i < input.length() &&

                        isdigit(input[i]))

            {

                val = (val*10) + (input[i]-'0');

                i++;

            }

            i--;

            val=val*num;

            values.push(val);

        }

        // if number after an operator is negative

        else if(input[i]=='-' && (prev=='-' || prev=='+' || prev=='*' || prev=='/'))  {

                   int num=-1;

             i++;

             int val = 0;

            

            // There may be more than one

            // digits in number.

            while(i < input.length() &&

                        isdigit(input[i]))

            {

                val = (val*10) + (input[i]-'0');

                i++;

            }

            i--;

            val=val*num;

            values.push(val);

        }

        // Current token is an operator.

        else

        {

            // While top of 'ops' has same or greater

            // precedence to current token, which

            // is an operator. Apply operator on top

            // of 'ops' to top two elements in values stack.

            if(input[i]=='-')  prev='-';

            if(input[i]=='+')  prev='+';

            if(input[i]=='*')  prev='*';

            if(input[i]=='/') prev='/';

            while(!ops.empty() && precedence(ops.top())

                                >= precedence(input[i])){

                int val2 = values.top();

                values.pop();

                

                int val1 = values.top();

                values.pop();

                

                char op = ops.top();

                ops.pop();

                

                values.push(applyOp(val1, val2, op));

            }

            

            // Push current token to 'ops'.

            ops.push(input[i]);

        }

    }

    

    // Entire expression has been parsed at this

    // point, apply remaining ops to remaining

    // values.

    while(!ops.empty()){

        int val2 = values.top();

        values.pop();

                

        int val1 = values.top();

        values.pop();

                

        char op = ops.top();

        ops.pop();

              

        values.push(applyOp(val1, val2, op));

    }

    

    // Top of 'values' contains result, return it.

    return values.top();

}

int main() {

    string input;

    getline(cin,input);

    cout << evaluate(input) << "\n";

    return 0;

}