Question

write a program in c++

Read an infix expression from an input file and convert to postfix. Instead of displaying directly on the screen, first place in a queue, and then display the contents of the queue on the screen.

Precondition:

• The expression will be read from a file (input.txt) that contains a single line. There will be no spaces between the operands and the operators.
• The following operators are allowed: ( ) + - * /
  • The normal rules of precedence will apply.
• No error checking is necessary.
• The numbers will all be greater than 0 and less than 10 (positive, single digit numbers)

Example:

1+2

converts to

12+

Answer 1

INPUT

##########

Input to the program is a text file "input.txt" as shown in the screenshot below

########################### PGM START ###################################

#include<bits/stdc++.h>
#include<fstream>

using namespace std;

#define SIZE 100

//********************** Stack implementation
class Stack
{
    int top;
public:
    char a[SIZE];  

    Stack(){
       //initialising top of stack as -1
       //which measn empty stack
       top = -1;
   }
   //function declaration
    bool push(char x);
    char pop();
    bool isEmpty();
    char topElement();
};
//function to push character into stack
bool Stack::push(char x)
{
   //checking the overflow condition in the stack
    if (top >= (SIZE-1))
    {
        cout << "Stack Overflow";
        return false;
    }
    else
    {
       //pushing element to stack
        a[++top] = x;
        return true;
    }
}

//returns the first top elemnt of the stack
char Stack::topElement()
{
    if (top < 0)
    {
        cout << "empty Stack";
        return 'N';
    }
    else
    {
        char x = a[top];
        return x;
    }
}
//pop() remove the top element from stack
char Stack::pop()
{
    if (top < 0)
    {
        cout << "Stack Underflow";
        return 'N';
    }
    else
    {
        char x = a[top--];
        return x;
    }
}
//isEmpty() checks if stack is empty or not
bool Stack::isEmpty()
{
    return (top < 0);
}

//**************************** Queue Implementation
class Queue
{
    int front,rear;
public:
    char a[SIZE];  

    Queue(){
       rear=-1;
       front=0;
   }
   //function declaration
    bool enqueue(char x);
    char dequeue();
    bool isEmpty();
};

bool Queue::enqueue(char x)
{
   //checking the overflow condition for queue
    if (rear >= (SIZE-1))
    {
        cout << "Queue Overflow";
        return false;
    }
    else
    {
       //inserting element to queue
        a[++rear] = x;
        return true;
    }
}
//dequeue() remove the front element from queue
char Queue::dequeue()
{
    if (rear < 0)
    {
        cout << "Queue Underflow";
        return 'N';
    }
    else
    {
        char x = a[front++];
        return x;
    }
}
//isEmpty() checks if queue is empty or not
bool Queue::isEmpty()
{
    return (front>rear);
}

//************************Infix to postfix conversion ***
//Function to return precedence of operators
int precedenceValue(char c){
    if(c == '*' || c == '/')
       return 2;
   else if(c == '+' || c == '-')
       return 1;
    else
       return -1;
}
/*
infixToPostfix() function converts infix expression
to postfix expression
*/
void infixToPostfix(string s)
{
    Stack st;
    Queue q;
    int l = s.length();
    string finalString;
    for(int i = 0; i < l; i++)
    {
        // If the character is an operand, append it to queue
       if((s[i] >= '0' && s[i] <= '9'))
           q.enqueue(s[i]);

        // If the character is an ‘(‘, push it to the stack.
        else if(s[i] == '(')
            st.push('(');
       
        // If the character is an ‘)’, pop and to output string from the stack
        // until an ‘(‘ is seen
        else if(s[i] == ')'){
            while(!st.isEmpty() && st.topElement() != '(')
            {
                char c = st.topElement();
                st.pop();
                q.enqueue(c);
            }
            if(st.topElement() == '(')
            {
                char c = st.topElement();
                st.pop();
            }
        }
        //If an operator is scanned, if the precedence of current operator is less than one in stack
        //pop th eoperator in stack and enqueue i to queue
        //else push the operator to stack
        else{
            while(!st.isEmpty() && precedenceValue(s[i]) <= precedenceValue(st.topElement())){
                char c = st.topElement();
                st.pop();
                 q.enqueue(c);
            }
            st.push(s[i]);
        }

    }
    //Pop all the remaining elements from the stack
    //enqueue it to queue
    while(!st.isEmpty())
   {
        char c = st.topElement();
        st.pop();
         q.enqueue(c);
    }
  
    //removing elements one by one from queue to get final string
   while(!q.isEmpty()){
       finalString+=q.dequeue();
   }
   
    cout <<"Postfix Notation = "<< finalString << endl;

}

// Driver program to test above functions
int main()
{
   string s;
  
   //reading the infix expression from input.txt file
   //file have only one line
   fstream infile;
   infile.open("input.txt");
  
   //storing the line read into string s
   getline(infile,s);
   cout<<"Infix Expression = "<<s<<"\n";
  
   //calling infixto postfix conversion function
   infixToPostfix(s);

    return 0;
}

################################ PGM END #################################

Output Screenshot

#################