Question

I really need help with a stack class that takes integer values for expression processing. Here are the requirements for the assignment:

• Remove any whitespace between characters from the input.
• Verify there are no invalid characters in the input, and if there are then print an error message.
• Print the expression out as an infix expression.
• Convert that to a postfix expression and print it.
• Evaluate the postfix expression and print the result (invalid expressions should print an error message).
• Expressions can only have single-digit positive numbers.
• Utilize the operators +, -, *, /, and ().
• CREATE YOUR OWN STACK CLASS, DO NOT USE <stack> (pop & push methods).
• Use only #include<iostream>, no other #include files.
• Provide comments for displaying logic progression.
• Must be done in C++.

Please follow the requirements, thank you very much.

Answer 1

// program code for the above given question

//Code follows as

//Program with all comments

#include <iostream>
#include <string>
#include<stack>
#include<cmath>
using namespace std;

// Function to return operator precedence
int getOperatorPrecedence(char operatorSymbol)
{
// Checks if parameter character is '^' then return priority as 3
if(operatorSymbol == '^')
return 3;

// Otherwise checks if parameter character is '/' or '*' then return priority as 2
else if(operatorSymbol == '/' || operatorSymbol == '*')
return 2;

// Otherwise checks if parameter character is '+' or '-' then return priority as 1
else if(operatorSymbol == '+' || operatorSymbol == '-')
return 1;

// For rest of the operators return 0
else
return 0;
}// End of function

// Function to calculate and return result based on the operator symbol
int Evaluate(int firstOperand, int secondOperand, char operatorSymbol)
{
// Checks if operator is '+'
if(operatorSymbol == '+')
// Adds and returns result
return firstOperand + secondOperand;

// Checks if operator is '-'
else if(operatorSymbol == '-')
// Subtracts and returns result
return firstOperand - secondOperand;

// Checks if operator is '*'
else if(operatorSymbol == '*')
// Multiplies and returns result
return firstOperand * secondOperand;

// Checks if operator is '/'
else if(operatorSymbol == '/')
// Divides and returns result
return firstOperand / secondOperand;

// Checks if operator is '^'
else if(operatorSymbol == '^')
return pow(firstOperand, secondOperand);
}// End of function

// Function to receive an infix expression and converts it to postfix expression
// Returns the postfix expression
string ConvertInfixToPostfix(string infixExpression)
{
// To store the postfix expression
string postfixExpression = "";
// Stack class object declared
stack <char> expressionStack;
// To store the character extracted from expression
char character;

for(int c = 0; infixExpression[c]; c++)
{
character = infixExpression[c];

// Checks if current character is left parenthesis
if(character == '(')
expressionStack.push(character);

// Checks if current character is right parenthesis
else if(character == ')')
{
// Loops till stack is empty or right parenthesis encountered
while(!expressionStack.empty() && expressionStack.top() != '(')
{
// Adds the characters from the stack to postfix expression
postfixExpression = postfixExpression + expressionStack.top();
// Pops the element from stack
expressionStack.pop();
}// End of while loop

// Checks if stack is not empty and stack top element is left parenthesis
if(!expressionStack.empty() && expressionStack.top() == '(')
// Pop the element from the stack
expressionStack.pop();
}// End of else if

// Otherwise current character is operator or operand
else
{
// Calls the function to find out the precedence
int priority = getOperatorPrecedence(character);

// Checks if priority is zero then the character is operand
if(priority == 0)
// Adds the operand to postfix expression
postfixExpression = postfixExpression + character;

// Otherwise current character is operator
else
{
// Checks if stack is empty
if(expressionStack.empty())
// Pushes the operator character to stack
expressionStack.push(character);

// Otherwise stack is not empty
else
{
// Loops till stack is not empty and stack top character is not left parenthesis
// and current operator priority is less or equals to stack top operator priority
while(!expressionStack.empty() && expressionStack.top() != '('
&& priority <= getOperatorPrecedence(expressionStack.top()))
{
// Adds the stack top operator character to postfix expression
postfixExpression = postfixExpression + expressionStack.top();
// Pops the element from stack
expressionStack.pop();
}// End of while loop

// Push the character to stack
expressionStack.push(character);
}// End of else
}// End of else
}// End of else
}// End of for loop

// Loops till stack is not empty
while(!expressionStack.empty())
{
// Extracts the stack top character and concatenates it with postfix expression
postfixExpression += expressionStack.top();
expressionStack.pop();
}// End of while

// Returns the postfix result
return postfixExpression;
}// End of function

// Function to evaluate postfix expression and returns the result
int EvaluatePostfixExpression(string postfixExpression)
{
// Stack class object declared
stack <int> expressionStack;
// To store the character extracted from expression
char character;
// To store first and second operand
int firstOperand, secondOperand;

// Loops till end of the postfix expression
for(int c = 0; postfixExpression[c]; c++)
{
// Extracts the current character
character = postfixExpression[c];

if(character >= '0' && character <= '9')
// Converts the character to integer and pushes to stack
expressionStack.push(character - '0');

else
{
// Extracts the top element from the stack second operand
secondOperand = expressionStack.top();
// Extracts the top element from the stack
expressionStack.pop();

// Extracts the top element from the stack as first operand
firstOperand = expressionStack.top();
expressionStack.pop();

// Pushes the calculated result to stack top
expressionStack.push(Evaluate(firstOperand, secondOperand, character));
}// End of else
}// End of for loop

// Returns the stack top element as postfix result
return expressionStack.top();
}// End of function

// Main function definition
int main()
{
// To store index and postfix expression
string infixExpression, postfixExpression;
// To store the result
int result;

// Creates an infix expression
infixExpression = "(1+(2^3)*4)/3";

// Calls the function to convert infix expression to postfix expression
postfixExpression = ConvertInfixToPostfix(infixExpression);

// Displays infix expression
cout<<"Infix Expression: "<<infixExpression<<endl;

// Displays converted postfix expression
cout<<"Postfix Expression: "<<postfixExpression<<endl;

// Calls the function to evaluate expression and displays result
cout<<"\nResult is: "<<EvaluatePostfixExpression(postfixExpression)<<endl;

return 0;
}// End of main function

Sample Output:

Infix Expression: (1+(2^3)*4)/3
Postfix Expression: 123^4*+3/

Result is: 11

-------------------------------------------------------------------------------------

%%%%%%%%%%%%%%%%%%% Please Give Positive Rating%%%%%%%%%%%%%%%