Balanced Parentheses in Java

The balanced parentheses problem is one of the common programming problems that is also known as Balanced brackets. This problem is commonly asked by the interviewers where we have to validate whether the brackets in a given string are balanced on not.

Characters such as "(", ")", "[", "]", "{", and "}" are considered brackets.

A collection of parentheses is considered to be a matched pair if the opening bracket occurs to the left of the corresponding closing bracket respectively.

If the brackets enclosed in a string are not matched, bracket pairs are not balanced.

In the same way, a string having non-bracket characters such as a-z, A-Z, 0-9 and other special characters such as #, $, and @ is also considered to be unbalanced.

Example "{[(])}"

It is an unbalanced input string because the pair of round brackets, "()", encloses a single unbalanced closing square bracket, "]", and the pair of square brackets, "[]", encloses a single unbalanced opening round bracket, "(".

A string having brackets is said to be balanced if:

A matching closing bracket occurs to the right of each corresponding opening bracket.
Brackets enclosed within balanced brackets should also be balanced
It should not contain any non-bracket character.

Note 1: Null is considered to be balanced.

Note 2: Empty string is considered to be balanced.

Algorithm (Deque)

First, we declare a character stack.
Convert input string into a character array.
Traverse the input string(By traversing the character array).
1. We push the current character to stack if it is a starting bracket('(' or '{' or '[').
2. We pop the current character from the stack if it is a closing bracket. If the popped character doesn't match with the starting bracket, brackets are not balanced.
Once the traversing is finished and there are some starting brackets left in the stack, the brackets are not balanced.

We can implement the code for balanced parentheses by using simple for loop, Deque and stack.

BalancedParenthesesExample1.java

// import required classes and package, if any 
 
import java.util.*; 
 
// create class BalancedParenthesesExample1 for implementing Balanced Parentheses using stack 
public class BalancedParenthesesExample1 { 
    
    // create method balancedParenthesis() to check whether the input string is balanced or not 
    @SuppressWarnings({ "rawtypes", "unchecked" }) 
    public static boolean balancedParenthesis(String inputStr) { 
        
        // create an empty stack 
        Stack stack = new Stack(); 
        
        // convert inputStr to char array 
        char[] charArray = inputStr.toCharArray(); 
        
        // iterate charArray 
        for (int i = 0; i < charArray.length; i++) { 
            
            // get char 
            char current = charArray[i]; 
            
            //check whether current is '(', '[' or '{' 
            if (current == '{' || current == '[' || current == '(') { 
                // push current to stack 
                stack.push(current); 
                continue; 
            } 
            // if stack is empty, return false 
            if (stack.isEmpty()) {  
                return false; 
            } 
            
            // use switch statement to pop element from stack and if it is '(', '[' or '{', return false 
            char popChar; 
            switch (current) { 
                case ')': 
                popChar = (char) stack.pop(); 
                if (popChar == '{' || popChar == '[') 
                    return false; 
                break; 
                case '}': 
                popChar = (char) stack.pop(); 
                if (popChar == '(' || popChar == '[') 
                    return false; 
                break; 
                case ']': 
                popChar = (char) stack.pop(); 
                if (popChar == '(' || popChar == '{') 
                    return false; 
                break; 
            } 
        } 
        return (stack.isEmpty()); 
    } 
    // main() method start 
    public static void main(String[] args) { 
        
        String inputStr; 
        
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        System.out.println("Enter input string to check:"); 
        // take input sring from user 
        inputStr = sc.nextLine(); 
        
        // call balancedParenthesis() method to check whether input string is balanced of not 
        if (balancedParenthesis(inputStr)) 
            System.out.println("Input string "+inputStr+" is balanced."); 
        else 
            System.out.println("Input string "+inputStr+" is not balanced."); 
    } 
}

Output:

BalancedParenthesesExample2.java

// import required classes and package if any 
import java.util.Scanner; 
 
//create class BalancedParenthesesExample2 for implementing Balanced Parentheses using simple for loop 
public class BalancedParenthesesExample2 { 
    // main() method start 
    public static void main(String[] args) 
    { 
        
        String inputStr; 
        int i, length, j=0, count=0; 
        char current, ch; 
        
        // create an empty stack 
        char[] stack = new char[20]; 
        
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        System.out.print("Enter an expression to check whether it is balanced or not: \n"); 
        inputStr = sc.nextLine(); 
        
        // close Scanner class object 
        sc.close(); 
        
        // get length of inputStr 
        length = inputStr.length(); 
        
        // use for loop for iterating input string 
        for(i = 0; i < length; i++) { 
            
            current = inputStr.charAt(i); 
            
            // check whether current is '(', '{', or '[' 
            if(current =='(' || current =='{' || current =='[') { 
                stack[j] = current; 
                j++;	// increment counter j 
                count = 1;	// set count to 1 
            } else if(current == ')') {		//if current char is ')' 
                if(count == 1) //if count is 1, decrement counter j 
                    j--; 
                ch = stack[j];	//store stack[j] to ch 
                if(stack.length == 0 || ch != '(') {	//if stack is empty or ch is an opening bracket '(', parentheses is not balanced  
                    System.out.println("\nUnbalanced Parentheses!"); 
                    return; 
                } 
            } else if(current == '}') {	//if current char is '}' 
                if(count == 1)	//if count is 1, decrement counter j 
                    j--; 
                ch = stack[j];	//store stack[j] to ch 
                if(stack.length == 0 || ch != '{') {	//if stack is empty or ch is an opening bracket '{', parentheses is not balanced 
                    System.out.println("\nUnbalanced Parentheses!"); 
                    return; 
                } 
            } else if(current == ']') {	//if current char is '}' 
                if(count == 1)	//if count is 1, decrement counter j 
                    j--; 
                ch = stack[j];	//store stack[j] to ch 
                if(stack.length == 0 || ch != '[') {	//if stack is empty or ch is an opening bracket '[', parentheses is not balanced 
                    System.out.println("\nUnbalanced Parentheses!"); 
                    return; 
                } 
            } 
        } 
        
        System.out.println("\nBalanced Parentheses."); 
    } 
} 

Output:

BalancedParenthesesExample3.java

//import required classes and package, if any 
 
import java.util.Deque; 
import java.util.LinkedList; 
import java.util.Scanner; 
 
//create class BalancedParenthesesExample3 for implementing Balanced Parentheses using Deque 
public class BalancedParenthesesExample3 { 
    
    // main() method start 
    public static void main(String[] args) 
    { 
        
        String inputStr; 
        
        // create an empty deque using LinkedList 
        Deque<Character> deque = new LinkedList<>(); 
        
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        System.out.print("Enter an expression to check whether it is balanced or not: \n"); 
        inputStr = sc.nextLine(); 
        
        // close Scanner class object 
        sc.close(); 
        
        //iterate input string using for 
        for(char ch : inputStr.toCharArray()) { 
            // add element to deque if ch = '{', ch = '[', or ch = '(' 
            if(ch == '{' || ch == '[' || ch == '(') { 
                deque.add(ch); 
            } else { 
                // if deque is not empty 
                if(! deque.isEmpty()) { 
                    if((deque.peekFirst() == '{' && ch == '}') 
                       || (deque.peekFirst() == '[' && ch == ']') 
                       || (deque.peekFirst() == '(' && ch == ')')) { 
                           deque.removeFirst(); 
                       } 
                }else { 
                    System.out.println("\nUnbalanced Parentheses2."); 
                } 
            } 
        } 
        System.out.println("\nBalanced Parentheses."); 
    } 
} 

Output: