Java Program to Check Balanced Parentheses Using Stack Algorithm

package stacks;

import java.util.Scanner;

//Node Implementation of the Stack using LinkedList
class Node1 {
    char val; //character value to store the parenthesis values
    Node1 nextNode; //Link to the next node

    public Node1(char value) {
        this.val = value;
        this.nextNode = null;
    }
}

//Class StackNew for different Stack operations
class StackNew {
    Node1 headNode = null; //Header or Top Node of the Stack

    //Push operation of the Stack
    public void push(char val) {
        Node1 newNode = new Node1(val);
        newNode.nextNode = headNode;
        headNode = newNode;
    }

    //Pop operation of the Stack
    public char pop() {
        if (this.headNode == null) {
            System.out.println("UnderFlow! The Stack is Empty !");
            return 0;
        } else {
            char currentVal = this.headNode.val;
            this.headNode = this.headNode.nextNode;
            return currentVal;
        }
    }

    //Peek operation of the Stack i.e. returns the First element of the Stack
    public char peek() {
        if (this.headNode == null) {
            System.out.println("UnderFlow! The Stack is Empty !");
            return 0;
        } else {
            return this.headNode.val;
        }
    }

    //isEmpty function of the stack to check whether the stack is empty or not
    public boolean isEmpty() {
        if (this.headNode == null) {
            return true;
        } else {
            return false;
        }
    }

}

//Implementation class to check whether the String with parenthesis is balanced or not
public class BalancedBrackets {

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

        char[] inputArray = inputPattern.toCharArray();
        StackNew stack = new StackNew();

        for (int i = 0; i < inputArray.length; i++) {
            if (inputArray[i] == '[' || inputArray[i] == '{' || inputArray[i] == '(') {
                stack.push(inputArray[i]);
            } else if ((stack.peek() == '[' && inputArray[i] == ']') || (stack.peek() == '{' && inputArray[i] == '}') || (stack.peek() == '(' && inputArray[i] == ')')) {
                stack.pop();
            }
        }

        if (stack.isEmpty()) {
            System.out.println("Balanced Stack");
        } else {
            System.out.println("Un-Balanced Stack");
        }
    }

}

(()){}() Balanced Stack

[()]{}{()()} Balanced Stack

[(]) Un-Balanced Stack