Step 1: Create a Node class with data and next pointer.
    Step 2: Implement push by adding a new node at the head.
    Step 3: Implement pop by removing the head node.
    Step 4: Implement peek by returning the data of the head node.
  

class Node {
    int data;
    Node next;
    
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedListStack {
    private Node head;

    public void push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    public int pop() {
        if (head == null) throw new IllegalStateException("Stack is empty");
        int data = head.data;
        head = head.next;
        return data;
    }

    public int peek() {
        if (head == null) throw new IllegalStateException("Stack is empty");
        return head.data;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedListStack stack = new LinkedListStack();
        stack.push(10);
        stack.push(20);
        System.out.println("Top element: " + stack.peek());
        System.out.println("Popped element: " + stack.pop());
    }
}
    

Top element: 20
Popped element: 20

    Step 1: Initialize an empty stack and result string.
    Step 2: Traverse the expression.
    Step 3: If operand, add to result.
    Step 4: If operator, pop from stack until stack top has less precedence.
    Step 5: Push current operator on stack.
    Step 6: Pop remaining operators from stack to result.
  

import java.util.Stack;

public class InfixToPostfix {
    public static int precedence(char ch) {
        switch (ch) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            case '^':
                return 3;
        }
        return -1;
    }

    public static String infixToPostfix(String expression) {
        StringBuilder result = new StringBuilder();
        Stack<Character> stack = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);

            if (Character.isLetterOrDigit(c)) {
                result.append(c);
            } else if (c == '(') {
                stack.push(c);
            } else if (c == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    result.append(stack.pop());
                }
                stack.pop();
            } else {
                while (!stack.isEmpty() && precedence(c) <= precedence(stack.peek())) {
                    result.append(stack.pop());
                }
                stack.push(c);
            }
        }

        while (!stack.isEmpty()) {
            result.append(stack.pop());
        }

        return result.toString();
    }

    public static void main(String[] args) {
        String expression = "a+b*(c^d-e)^(f+g*h)-i";
        System.out.println("Postfix expression: " + infixToPostfix(expression));
    }
}
    

Postfix expression: abcd^e-fgh*+^*+i-

    Step 1: Initialize an empty stack.
    Step 2: Traverse the expression.
    Step 3: Push opening brackets onto the stack.
    Step 4: On closing bracket, pop from stack and check for match.
    Step 5: If stack is empty at end, parentheses are balanced.
  

import java.util.Stack;

public class BalancedParentheses {
    public static boolean isBalanced(String expression) {
        Stack<Character> stack = new Stack<>();

        for (char ch : expression.toCharArray()) {
            if (ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            } else if (ch == ')' || ch == '}' || ch == ']') {
                if (stack.isEmpty()) return false;
                char open = stack.pop();
                if (!isMatchingPair(open, ch)) return false;
            }
        }

        return stack.isEmpty();
    }

    private static boolean isMatchingPair(char open, char close) {
        return (open == '(' && close == ')') ||
               (open == '{' && close == '}') ||
               (open == '[' && close == ']');
    }

    public static void main(String[] args) {
        String expression = "{[()]}";
        System.out.println("Is balanced: " + isBalanced(expression));
    }
}
    

Is balanced: true