Question

Convert infix to postfix, and evaluate postfix using custom Stack created using a singly linked list. This is only supposed to use THAT method, calling a normal Stack will give me a zero. I do have the conversion to postfix, but there may be error in there. But the main problem currently is the evaluation of postfix. I keep getting an error that I made for an empty stack, which I will include. For testing it is only supposed to take in single integers (nothing more.) This is supposed to read in input, (WITHOUT spaces, very basic.) Any and all corrections are welcome. Here is my code:

LinkedStack class:

public class LinkedStack {
   private Node top;
   private int size;
   private class Node {
       private Node next;
       private Object data;
       public Node(Object e, Node n) {
           this.data = e;
           this.next = null;
       }
  
   }
  
   public LinkedStack() {
       this.top = null;
       this.size = 0;
   }
  
   public int size() {
       return this.size;
   }
  
   public Object top() {
       if (isEmpty()) {
           throw new EmptyStackException("");
       }
       return this.top.data;
   }
  
   public void push(Object elem) {
       Node nn = new Node(elem,this.top);
       this.top = nn;
       this.size++;
   }
  
  
  
   public Object pop() throws EmptyStackException {
       if (isEmpty()) {
           throw new EmptyStackException("");
       }
       Object temp = this.top.data;
       this.top = this.top.next;
       this.size--;
       return temp;
      
   }
  
   public boolean isEmpty() {
       return (this.top == null || this.size == 0 );
   }
  
}

*My EmptyStackException*
public class EmptyStackException extends RuntimeException{
       public EmptyStackException(String err) {
           super(err);
       }
      
   }

*And here is the infix to postfix, postfix eval, precedence check, and main:

import java.util.Scanner;
public class postfix {
   //Read in infix expression check
   //Covert infix to postfix check
   //Evaluate postfix
   //Display original infix, corresponding postfix, and final result on screen
   private static String convertToPostfix (String infix) {
       String postfixResult = new String("");
       LinkedStack stack = new LinkedStack();
      
       for (int i = 0; i < infix.length(); ++i) {
           char c = infix.charAt(i);
           if (Character.isLetterOrDigit(c)) {
               postfixResult += c;
           }

           else if (c == '(') {
               stack.push(c);
           }
          
           else if (c == '(') {
               while (!stack.isEmpty() && (char)stack.top() != '(') {
                   postfixResult += stack.pop();
               }
               if (!stack.isEmpty() && (char)stack.top() != '(') {
                   return null;
               }
               else {
                   stack.pop();
               }
           }
          
           else {
               while(!stack.isEmpty() && precedence(c) <= precedence((char)stack.top()) ) {
                   postfixResult += stack.pop();
               }
              
               stack.push(c);
           }
          
          
       }
      
       while(!stack.isEmpty()) {
           postfixResult += stack.pop();
       }
       return postfixResult;  
   }
  
   public static int evalPostFix(String in) {
       LinkedStack stack = new LinkedStack();
       for (int i = 0; i < in.length(); i++) {
           char c = in.charAt(i);
          
           if (Character.isDigit(c)) {
              
               stack.push(c);
           }
              
               else {
                   int value1 = (int)stack.pop();
                   int value2 = (int)stack.pop();
                  
                   switch(c) {
                   case '+':
                       stack.push(value2 + value1);
                       break;
                   case '-':
                       stack.push(value2 - value1);
                       break;
                   case '/':
                       stack.push(value2 / value1);
                       break;
                   case '*':
                       stack.push(value2 * value1);
                       break;
                   case '^':
                       stack.push(value2 ^ value1);
                       break;
                  
               }
              
           }
          
       }
      
       int returnval = (int)stack.pop();
       return returnval;
      
   }
      
  
   static int precedence(char c) {
       switch (c) {
       case '+':
       case '-':
           return 1;
       case '/':
       case '*':
           return 2;
       case '^':
           return 3;
      
   }
       return -1;
   }
  
   public static void main(String [] args) {
       //postfix obj = new postfix();
       Scanner sc= new Scanner(System.in);
       System.out.println("Infix : \t ");
       String exp = sc.nextLine();
       String postfix = convertToPostfix(exp);
       System.out.println("Postfix: " + convertToPostfix(exp));
      
       int evalPostFix = evalPostFix(postfix);
       System.out.println("Postfix evaluation: " + evalPostFix);
      
   }
}

Answer 1

There was an error in your LinkedStack.java file, inside Node class constructor, the next node was not getting initialized. Fixed it. There were so many casting errors in postfix.java, fixed it and now everything works fine (for single digit integers only, and no blank spaces in input).

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

// LinkedStack.java

public class LinkedStack {

      private Node top;

      private int size;

      private class Node {

            private Node next;

            private Object data;

            public Node(Object e, Node n) {

                  this.data = e;

                  // assigning n as next node, earlier, it was assigned null

                  this.next = n;

            }

      }

      public LinkedStack() {

            this.top = null;

            this.size = 0;

      }

      public int size() {

            return this.size;

      }

      public Object top() {

            if (isEmpty()) {

                  throw new EmptyStackException("");

            }

            return this.top.data;

      }

      public void push(Object elem) {

            Node nn = new Node(elem, this.top);

            this.top = nn;

            this.size++;

      }

      public Object pop() throws EmptyStackException {

            if (isEmpty()) {

                  throw new EmptyStackException("");

            }

            Object temp = this.top.data;

            this.top = this.top.next;

            this.size--;

            return temp;

      }

      public boolean isEmpty() {

            return (this.top == null || this.size == 0);

      }

}

// postfix.java

import java.util.Scanner;

public class postfix {

      // Read in infix expression check

      // Covert infix to postfix check

      // Evaluate postfix

      // Display original infix, corresponding postfix, and final result on screen

      private static String convertToPostfix(String infix) {

            String postfixResult = new String("");

            // initializing empty stack

            LinkedStack stack = new LinkedStack();

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

                  char c = infix.charAt(i);

                  // If the scanned character is an operand, add it to output.

                  if (Character.isLetterOrDigit(c))

                        postfixResult += 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() && (Character) stack.top() != '(')

                              postfixResult += stack.pop();

                        if (!stack.isEmpty() && (Character) stack.top() != '(')

                              return null;

                        else {

                              stack.pop(); // removing ( from the stack

                        }

                  } else // an operator is found, removing from the stack and

                              // appending to postfixResult as long as precedence of

                              // current operator is less than or equal to preceedence of

                              // operator on stack's top

                  {

                        while (!stack.isEmpty()

                                    && precedence(c) <= precedence((Character) stack.top()))

                              postfixResult += stack.pop();

                        stack.push(c);

                  }

            }

            // removing all the operators from the stack, appending to result

            while (!stack.isEmpty())

                  postfixResult += stack.pop();

            return postfixResult;

      }

      public static int evalPostFix(String in) {

            // creating a stack

            LinkedStack stack = new LinkedStack();

            // looping through each character

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

                  char c = in.charAt(i);

                  // If the character is an operand, pushing to stack

                  if (Character.isDigit(c))

                        stack.push((int) c - '0'); // (pushing as as integer)

                  // If the character is an operator, pop top two values from stack,

                  // applying the operator

                  else {

                        int val1 = (Integer) stack.pop();

                        int val2 = (Integer) stack.pop();

                        switch (c) {

                        case '+':

                              stack.push(val2 + val1);

                              break;

                        case '-':

                              stack.push(val2 - val1);

                              break;

                        case '/':

                              stack.push(val2 / val1);

                              break;

                        case '*':

                              stack.push(val2 * val1);

                              break;

                        case '^':

                              stack.push((int) Math.pow(val2, val1));

                              break;

                        }

                  }

            }

            return (Integer) stack.pop();

      }

      static int precedence(char c) {

            switch (c) {

            case '+':

            case '-':

                  return 1;

            case '/':

            case '*':

                  return 2;

            case '^':

                  return 3;

            }

            return -1;

      }

      public static void main(String[] args) {

            // postfix obj = new postfix();

            Scanner sc = new Scanner(System.in);

            System.out.println("Infix : \t ");

            String exp = sc.nextLine();

            String postfix = convertToPostfix(exp);

            System.out.println("Postfix: " + convertToPostfix(exp));

            int evalPostFix = evalPostFix(postfix);

            System.out.println("Postfix evaluation: " + evalPostFix);

      }

}

/*OUTPUT*/

Infix :    

(3*5)-(8/4)+8

Postfix: 35*84/-8+

Postfix evaluation: 21