Moved StackPostfixNotation.java from the Others section to the Stack section (#4372)

* Moved StackPostfixNotation.java from the Others section to the Stack section

* Put all stack related algo in a separate stack directory in the algorithms directory. The stack directory under data-structures now only contains various implementations of the stack data structure.

* formatted files

src/main/java/com/thealgorithms/stacks/PostfixToInfix.java

@@ -0,0 +1,129 @@
+package com.thealgorithms.stacks;
+
+import java.util.Stack;
+
+/**
+ * Postfix to Infix implementation via Stack
+ *
+ * Function: String getPostfixToInfix(String postfix)
+ * Returns the Infix Expression for the given postfix parameter.
+ *
+ * Avoid using parentheses/brackets/braces for the postfix string.
+ * Postfix Expressions don't require these.
+ *
+ *
+ * @author nikslyon19 (Nikhil Bisht)
+ *
+ */
+
+public class PostfixToInfix {
+
+    public static boolean isOperator(char token) {
+        switch (token) {
+        case '+':
+        case '-':
+        case '/':
+        case '*':
+        case '^':
+            return true;
+        }
+
+        return false;
+    }
+
+    public static boolean isValidPostfixExpression(String postfix) {
+        /* Postfix expression length should NOT be less than 3 */
+        if (postfix.length() < 3) return false;
+
+        /* First two characters should NOT be operators */
+        if (isOperator(postfix.charAt(0))) return false;
+        if (isOperator(postfix.charAt(1))) return false;
+
+        int operandCount = 0;
+        int operatorCount = 0;
+
+        /* Traverse the postfix string to check if --> Number of operands = Number of operators + 1
+         */
+        for (int i = 0; i < postfix.length(); i++) {
+            char token = postfix.charAt(i);
+
+            if (isOperator(token)) {
+                operatorCount++;
+                if (operatorCount >= operandCount) return false;
+            } else {
+                if (operatorCount == 0) {
+                    operandCount++;
+                    continue;
+                }
+
+                if (operandCount != operatorCount + 1) return false;
+
+                /* Operand count is set to 2 because:-
+                 *
+                 * 1) the previous set of operands & operators combined have become a single valid
+                 * expression, which could be considered/assigned as a single operand.
+                 *
+                 * 2) the operand in the current iteration.
+                 */
+                operandCount = 2;
+
+                /* Reset operator count */
+                operatorCount = 0;
+            }
+        }
+
+        return (operandCount == operatorCount + 1);
+    }
+
+    public static String getPostfixToInfix(String postfix) {
+        String infix = "";
+
+        if (postfix.isEmpty()) return infix;
+
+        /* Validate Postfix expression before proceeding with the Infix conversion */
+        if (!isValidPostfixExpression(postfix)) {
+            throw new IllegalArgumentException("Invalid Postfix Expression");
+        }
+
+        Stack<String> stack = new Stack<>();
+        StringBuilder valueString = new StringBuilder();
+
+        String operandA, operandB;
+        char operator;
+
+        for (int index = 0; index < postfix.length(); index++) {
+            char token = postfix.charAt(index);
+
+            if (!isOperator(token)) {
+                stack.push(Character.toString(token));
+                continue;
+            }
+
+            operator = token;
+            operandB = stack.pop();
+            operandA = stack.pop();
+
+            valueString.append('(');
+
+            valueString.append(operandA);
+            valueString.append(operator);
+            valueString.append(operandB);
+
+            valueString.append(')');
+
+            stack.push(valueString.toString());
+            valueString.setLength(0);
+        }
+
+        infix = stack.pop();
+        return infix;
+    }
+
+    public static void main(String[] args) {
+        assert getPostfixToInfix("ABC+/").equals("(A/(B+C))");
+        assert getPostfixToInfix("AB+CD+*").equals("((A+B)*(C+D))");
+        assert getPostfixToInfix("AB+C+D+").equals("(((A+B)+C)+D)");
+        assert getPostfixToInfix("ABCDE^*/-").equals("(A-(B/(C*(D^E))))");
+        assert getPostfixToInfix("AB+CD^/E*FGH+-^").equals("((((A+B)/(C^D))*E)^(F-(G+H)))");
+    }
+}