Question

Code should be written in java

Write a program to convert an infix expression to postfix expression using stack. Algorithm: a) Create a stack

b) For each character t in the input stream If(t is an operand) append t to the output. Else if (t is a right parenthesis) Pop and append to the output until a left parenthesis is popped (but do not append this parenthesis to the output). Else if(t is an operator or left parenthesis) Pop and append to the output until one of the lower priority than t is encountered or a left parenthesis is encountered or the stack is empty. Push t c)

Pop and append to the output until the stack is empty.

Answer 1

For the above problem, we need to have the following things into consideration.

1. We need to put the operands directly to output.
2. If there are operators then we need to check the precedence
   1. We need to pop all the operators which are of the same or greater precedence from the stack.
   2. Then we can put the operator onto the stack.
3. So for checking the precedences of the operators, a method is made in the program.

Following is the program in java.

import java.util.Scanner;
import java.util.Stack;

public class ConvertInfixToPostfix
{
   // This is the function used for checking the
   // precedence of the characters
   static int precedence(char ch)
   {
       switch (ch)
       {
       case '+':
       case '-':
           return 1;
  
       case '*':
       case '/':
           return 2;
  
       case '^':
           return 3;
       }
       return -1;
   }
  
   // This is the function which
   // actually converts infix to
   // postfix
   static String infixToPostfix(String exp)
   {
       // String for result
       String result = new String("");
      
       // empty stack
       Stack<Character> stack = new Stack<>();
      
       for (int i = 0; i<exp.length(); ++i)
       {
           char c = exp.charAt(i);
          
           // Adding operand to the output
           if (Character.isLetterOrDigit(c))
               result += c;
          
           // If the scanned character is an '(', push it to the stack.
           else if (c == '(')
               stack.push(c);
          
           // If the scanned character is an ')', pop and output from the stack
           // until an '(' is encountered.
           else if (c == ')')
           {
               while (!stack.isEmpty() && stack.peek() != '(')
                   result += stack.pop();
              
               if (!stack.isEmpty() && stack.peek() != '(')
                   return "Invalid Expression"; // invalid expression                 
               else
                   stack.pop();
           }
           else // Operator
           {
               while (!stack.isEmpty() && precedence(c) <= precedence(stack.peek())){
                   if(stack.peek() == '(')
                       return "Invalid Expression";
                   result += stack.pop();
           }
               stack.push(c);
           }
  
       }
  
       // Popping all the operators
       while (!stack.isEmpty()){
           if(stack.peek() == '(')
               return "Invalid Expression";
           result += stack.pop();
       }
       return result;
   }
  
   // Driver method
   public static void main(String[] args)
   {
       Scanner scan = new Scanner(System.in);
       System.out.print("Infix: ");
       String infix = scan.next();
       String postFix = infixToPostfix(infix);
       System.out.println("PostFix: " + postFix);
   }
}

Output snippet.

That was a nice question to answer
Friend, If you have any doubts in understanding do let me know in the comment section. I will be happy to help you further.
Please like if you think effort deserves like.
Thanks