Infix to Postfix Conversion in Java

import java.util.*;

public class Main
{

    public static int precedence(char ch)
    {
        if(ch=='+' || ch=='-')
            return 1;

        else if(ch=='*' || ch=='/')
            return 2;                       // * and / divide have higher precedence.

        return 0;
    }

    public static String convertToPostfix(String exp)
    {
        Stack< Character> operators = new Stack<>();
        Stack< String> postFix = new Stack<>();

        for(int i=0;i < exp.length();i++) { char ch=exp.charAt(i); // current character.
        if(ch=='(') operators.push(ch);
        else if((ch>='a' && ch<='z') || (ch>='A' && ch<='Z')) postFix.push(ch+""); 
        else if(ch==')') 
        { 
            while(operators.peek()!= '(') { // STEP 5 of Algorithm.
            char op = operators.pop();
            String first = postFix.pop(); // get the two operands.
            String second = postFix.pop(); 
            String new_postFix = second+first+op; // add them in reverse order.
            postFix.push(new_postFix); // push the result to postFix stack again.
            } operators.pop(); // pop '(' from stack. 
            } // We do the same thing if we get an operator as the current character. 
            else if(ch=='+' || ch=='-' || ch== '*' || ch== '/') { // check precedence of each operator with top of the stack and process them.
            while(operators.size()>0 && operators.peek()!='(' && precedence(ch) <= precedence(operators.peek())) 
            {
                char op = operators.pop();
                String first = postFix.pop(); 
                String second = postFix.pop(); 
                String new_postFix = second+first+op;
                postFix.push(new_postFix); 
                
            } operators.push(ch); 
                
            } 
            
        } // If the operator stack still has some elements in it process them too Repeat Step 5. 
        while(operators.size()>0)
            {
                char op = operators.pop();

                String first = postFix.pop();
                String second = postFix.pop();

                String new_postFix = second+first+op;

                postFix.push(new_postFix);
            }

            return postFix.pop();         // return resultant Postfix.
        }

        public static void main(String args[])
        {
            // We pass Uppercase Infix
            String infixExpression = "((a+(b*c))-d)";
            System.out.println("The Infix Expression is: "+infixExpression);
            String result = convertToPostfix(infixExpression);
            System.out.println("The Postfix of the given Infix Expression is: "+result);

            System.out.println();
        }
    }

import java.util.*;

class myStack {
    static final int MAX = 10;
    int top;
    char[] a = new char[MAX]; // Maximum size of Stack

    myStack()
    {
        top = -1;
    }

    boolean push(char x)
    {
        if (top >= (MAX - 1)) {
            System.out.println("Stack Overflow");
            return false;
        }
        else {
            a[++top] = x;
            return true;
        }
    }

    int pop()
    {
        if (top < 0) {
            System.out.println("Stack Underflow");
            return Integer.MIN_VALUE;
        }
        else {
            int x = a[top--];
            return x;
        }
    }

    char peek()
    {
        if (top < 0) {
            System.out.println("Stack Underflow");
            return 0;
        }
        else {
            char x = a[top];
            return x;
        }
    }
    int size(){
        return (top+1);
    }

    boolean isEmpty(){
        return top==-1;
    }

    boolean isFull(){
        return top == MAX - 1;
    }
}

class Main{
    static boolean checkIfOperand(char ch)
    {
        return Character.isLetterOrDigit(ch);
    }

    // Function to compare precedence
    // If we return larger value means higher precedence
    static int precedence(char ch)
    {
        switch (ch)
        {
            case '+':
            case '-':
                return 1;

            case '*':
            case '/':
                return 2;

            case '^':
                return 3;
        }
        return -1;
    }


    static StringBuilder covertInfixToPostfix(String expr)
    {
        int i;
        myStack s = new myStack();
        StringBuilder result = new StringBuilder(new String(""));

        for (i = 0; i < expr.length(); ++i)
        {
            // Here we are checking is the character we scanned is operand or not
            // and this adding to output.
            if (checkIfOperand(expr.charAt(i)))
                result.append(expr.charAt(i));

                // Here, if we scan the character ‘(‘, '[', '{' we need to push it to the stack.
            else if (expr.charAt(i) == '(' || expr.charAt(i) == '[' || expr.charAt(i) == '{')
                s.push(expr.charAt(i));

                // Here, if we scan character is an ‘)’, we need to pop and print from the stack
                // do this until an ‘(‘ is encountered in the stack.
            else if (expr.charAt(i) == ')' || expr.charAt(i) == ']' || expr.charAt(i) == '}')
            {
                if(expr.charAt(i) == ')'){
                    while (!s.isEmpty() && s.peek() != '('){
                        result.append(s.peek());
                        s.pop();
                    }

                    s.pop();
                }

                if(expr.charAt(i) == ']'){
                    while (!s.isEmpty() && s.peek() != '['){
                        result.append(s.peek());
                        s.pop();
                    }

                    s.pop();
                }
                if(expr.charAt(i) == '}'){
                    while (!s.isEmpty() && s.peek() != '{'){
                        result.append(s.peek());
                        s.pop();
                    }

                    s.pop();
                }
            }
            else // if an operator
            {
                while (!s.isEmpty() && precedence(expr.charAt(i)) <= precedence(s.peek())){
                    result.append(s.peek());
                    s.pop();
                }
                s.push(expr.charAt(i));
            }

        }

        // Once all initial expression characters are traversed
        // adding all left elements from stack to exp
        return result;

    }


    // Driver code
    public static void main(String[] args)
    {
        String infixExpression = "((a+(b*c))-d)";
        System.out.println("The Infix Expression is: "+infixExpression);
        StringBuilder result = covertInfixToPostfix(infixExpression);
        System.out.println("The Postfix of the given Infix Expression is: "+result);
    }
}