Postfix to Prefix Conversion in Java

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;

public class PostfixToPrefixConversion {

    // Checks if a character is an operator we support
    private static boolean isOperator(char ch) {
        return ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^';
    }

    // Checks if a character is an operand (letter or digit)
    // For beginner-friendly version: single-letter variables or single-digit numbers.
    private static boolean isOperand(char ch) {
        return Character.isLetterOrDigit(ch);
    }

    /**
     * Converts a postfix expression to prefix expression.
     * Assumptions:
     * - Operands are single letters/digits (A, b, 7, etc.)
     * - Operators are one of: +, -, *, /, ^
     * - Spaces are allowed and ignored
     *
     * @param postfix input postfix string
     * @return prefix expression string
     * @throws IllegalArgumentException if postfix is invalid
     */
    public static String postfixToPrefix(String postfix) {
        if (postfix == null) {
            throw new IllegalArgumentException("Input is null.");
        }

        String trimmed = postfix.trim();
        if (trimmed.isEmpty()) {
            throw new IllegalArgumentException("Input is empty.");
        }

        Deque stack = new ArrayDeque<>();

        for (int i = 0; i < postfix.length(); i++) {
            char ch = postfix.charAt(i);

            // Ignore whitespace
            if (Character.isWhitespace(ch)) {
                continue;
            }

            if (isOperand(ch)) {
                stack.push(String.valueOf(ch));
            } else if (isOperator(ch)) {
                // Underflow check: need two operands
                if (stack.size() < 2) {
                    throw new IllegalArgumentException(
                            "Invalid postfix expression: not enough operands for operator '" + ch + "'.");
                }

                String right = stack.pop();
                String left = stack.pop();

                // Build prefix: operator + left + right
                String combined = ch + left + right;
                stack.push(combined);
            } else {
                // Invalid character based on our rules
                throw new IllegalArgumentException(
                        "Invalid character '" + ch + "' found in expression.");
            }
        }

        // After processing, exactly one result should remain
        if (stack.size() != 1) {
            throw new IllegalArgumentException(
                    "Invalid postfix expression: leftover operands/operators (stack size = " + stack.size() + ").");
        }

        return stack.pop();
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Enter postfix expression (example: AB+C*):");
        String postfix = sc.nextLine();

        try {
            String prefix = postfixToPrefix(postfix);
            System.out.println("Prefix expression:");
            System.out.println(prefix);

            // Complexity note for this approach:
            // Time: O(n), Space: O(n)
            System.out.println("\nComplexity:");
            System.out.println("Time Complexity: O(n)");
            System.out.println("Space Complexity: O(n)");
        } catch (IllegalArgumentException ex) {
            System.out.println("Error: " + ex.getMessage());
        } finally {
            sc.close();
        }
    }
}