Check for balanced parentheses in an expression

Given an expression string exp, write a program to examine whether the pairs and the orders of “{“, “}”, “(“, “)”, “[“, “]” are correct in exp.

Example:

Input: exp = “[()]{}{[()()]()}”
Output: Balanced

Input: exp = “[(])”
Output: Not Balanced

check-for-balanced-parentheses-in-an-expression

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Algorithm:

Declare a character stack S.
Now traverse the expression string exp.
1. If the current character is a starting bracket (‘(‘ or ‘{‘ or ‘[‘) then push it to stack.
2. If the current character is a closing bracket (‘)’ or ‘}’ or ‘]’) then pop from stack and if the popped character is the matching starting bracket then fine else parenthesis are not balanced.
After complete traversal, if there is some starting bracket left in stack then “not balanced”

Below image is a dry run of the above approach:

Below is the implementation of the above approach:

C++

// CPP program to check for balanced parenthesis. 
#include <bits/stdc++.h> 
using namespace std; 
  
// function to check if paranthesis are balanced 
bool areParanthesisBalanced(string expr) 
{ 
    stack<char> s; 
    char x; 
  
    // Traversing the Expression 
    for (int i = 0; i < expr.length(); i++) { 
        if (expr[i] == '(' || expr[i] == '[' || expr[i] == '{') { 
            // Push the element in the stack 
            s.push(expr[i]); 
            continue; 
        } 
  
        // IF current current character is not opening 
        // bracket, then it must be closing. So stack 
        // cannot be empty at this point. 
        if (s.empty()) 
            return false; 
  
        switch (expr[i]) { 
        case ')': 
  
            // Store the top element in a 
            x = s.top(); 
            s.pop(); 
            if (x == '{' || x == '[') 
                return false; 
            break; 
  
        case '}': 
  
            // Store the top element in b 
            x = s.top(); 
            s.pop(); 
            if (x == '(' || x == '[') 
                return false; 
            break; 
  
        case ']': 
  
            // Store the top element in c 
            x = s.top(); 
            s.pop(); 
            if (x == '(' || x == '{') 
                return false; 
            break; 
        } 
    } 
  
    // Check Empty Stack 
    return (s.empty()); 
} 
  
// Driver program to test above function 
int main() 
{ 
    string expr = "{()}[]"; 
  
    if (areParanthesisBalanced(expr)) 
        cout << "Balanced"; 
    else
        cout << "Not Balanced"; 
    return 0; 
} 

C

#include <stdio.h> 
#include <stdlib.h> 
#define bool int 
  
/* structure of a stack node */
struct sNode { 
    char data; 
    struct sNode* next; 
}; 
  
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data); 
  
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref); 
  
/* Returns 1 if character1 and character2 are matching left 
   and right Parenthesis */
bool isMatchingPair(char character1, char character2) 
{ 
    if (character1 == '(' && character2 == ')') 
        return 1; 
    else if (character1 == '{' && character2 == '}') 
        return 1; 
    else if (character1 == '[' && character2 == ']') 
        return 1; 
    else
        return 0; 
} 
  
/*Return 1 if expression has balanced Parenthesis */
bool areParenthesisBalanced(char exp[]) 
{ 
    int i = 0; 
  
    /* Declare an empty character stack */
    struct sNode* stack = NULL; 
  
    /* Traverse the given expression to check matching parenthesis */
    while (exp[i]) { 
        /*If the exp[i] is a starting parenthesis then push it*/
        if (exp[i] == '{' || exp[i] == '(' || exp[i] == '[') 
            push(&stack, exp[i]); 
  
        /* If exp[i] is an ending parenthesis then pop from stack and  
          check if the popped parenthesis is a matching pair*/
        if (exp[i] == '}' || exp[i] == ')' || exp[i] == ']') { 
  
            /*If we see an ending parenthesis without a pair then return false*/
            if (stack == NULL) 
                return 0; 
  
            /* Pop the top element from stack, if it is not a pair  
            parenthesis of character then there is a mismatch. 
            This happens for expressions like {(}) */
            else if (!isMatchingPair(pop(&stack), exp[i])) 
                return 0; 
        } 
        i++; 
    } 
  
    /* If there is something left in expression then there is a starting 
      parenthesis without a closing parenthesis */
    if (stack == NULL) 
        return 1; /*balanced*/
    else
        return 0; /*not balanced*/
} 
  
/* UTILITY FUNCTIONS */
/*driver program to test above functions*/
int main() 
{ 
    char exp[100] = "{()}[]"; 
    if (areParenthesisBalanced(exp)) 
        printf("Balanced \n"); 
    else
        printf("Not Balanced \n"); 
    return 0; 
} 
  
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data) 
{ 
    /* allocate node */
    struct sNode* new_node = (struct sNode*)malloc(sizeof(struct sNode)); 
  
    if (new_node == NULL) { 
        printf("Stack overflow n"); 
        getchar(); 
        exit(0); 
    } 
  
    /* put in the data  */
    new_node->data = new_data; 
  
    /* link the old list off the new node */
    new_node->next = (*top_ref); 
  
    /* move the head to point to the new node */
    (*top_ref) = new_node; 
} 
  
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref) 
{ 
    char res; 
    struct sNode* top; 
  
    /*If stack is empty then error */
    if (*top_ref == NULL) { 
        printf("Stack overflow n"); 
        getchar(); 
        exit(0); 
    } 
    else { 
        top = *top_ref; 
        res = top->data; 
        *top_ref = top->next; 
        free(top); 
        return res; 
    } 
} 

Java

// Java program for checking 
// balanced Parenthesis 
import java.util.*; 
  
public class BalancedParan { 
  
    // function to check if paranthesis are balanced 
    static boolean areParanthesisBalanced(String expr) 
    { 
        // Using ArrayDeque is faster than using Stack class 
        Deque<Character> stack = new ArrayDeque<Character>(); 
  
        // Traversing the Expression 
        for (int i = 0; i < expr.length(); i++) { 
            char x = expr.charAt(i); 
  
            if (x == '(' || x == '[' || x == '{') { 
                // Push the element in the stack 
                stack.push(x); 
                continue; 
            } 
  
            // IF current current character is not opening 
            // bracket, then it must be closing. So stack 
            // cannot be empty at this point. 
            if (stack.isEmpty()) 
                return false; 
  
            switch (x) { 
            case ')': 
                stack.pop(); 
                if (x == '{' || x == '[') 
                    return false; 
                break; 
  
            case '}': 
                stack.pop(); 
                if (x == '(' || x == '[') 
                    return false; 
                break; 
  
            case ']': 
                stack.pop(); 
                if (x == '(' || x == '{') 
                    return false; 
                break; 
            } 
        } 
  
        // Check Empty Stack 
        return (stack.isEmpty()); 
    } 
  
    /*driver program to test above functions*/
    public static void main(String[] args) 
    { 
        String expr = "([{}])"; 
        if (areParanthesisBalanced(expr)) 
            System.out.println("Balanced "); 
        else
            System.out.println("Not Balanced "); 
    } 
} 

Python3

# Python3 program to check for 
# balanced parenthesis.  
  
# function to check if  
# paranthesis are balanced  
def areParanthesisBalanced(expr) : 
    stack = [] 
  
    # Traversing the Expression  
    for char in expr: 
        if char in ["(", "{", "["]: 
  
            # Push the element in the stack  
            stack.append(char) 
        else: 
  
            # IF current character is not opening  
            # bracket, then it must be closing.   
            # So stack cannot be empty at this point.  
            if not stack: 
                return False
            current_char = stack.pop() 
            if current_char == '(': 
                if char != ")": 
                    return False
            if current_char == '{': 
                if char != "}": 
                    return False
            if current_char == '[': 
                if char != "]": 
                    return False
  
    # Check Empty Stack 
    if stack: 
        return False
    return True
  
  
# Driver Code 
if __name__ == "__main__" :  
    expr = "{()}[]";  
    if areParanthesisBalanced(expr) : 
        print("Balanced");  
    else : 
        print("Not Balanced");  
  
# This code is contributed by AnkitRai01 and improved  
# by Raju Pitta 

C#

// C# program for checking 
// balanced Parenthesis 
using System; 
using System.Collections.Generic; 
  
public class BalancedParan { 
    public class stack { 
        public int top = -1; 
        public char[] items = new char[100]; 
  
        public void push(char x) 
        { 
            if (top == 99) { 
                Console.WriteLine("Stack full"); 
            } 
            else { 
                items[++top] = x; 
            } 
        } 
  
        char pop() 
        { 
            if (top == -1) { 
                Console.WriteLine("Underflow error"); 
                return '\0'; 
            } 
            else { 
                char element = items[top]; 
                top--; 
                return element; 
            } 
        } 
  
        Boolean isEmpty() 
        { 
            return (top == -1) ? true : false; 
        } 
    } 
  
    /* Returns true if character1 and character2 
    are matching left and right Parenthesis */
    static Boolean isMatchingPair(char character1, char character2) 
    { 
        if (character1 == '(' && character2 == ')') 
            return true; 
        else if (character1 == '{' && character2 == '}') 
            return true; 
        else if (character1 == '[' && character2 == ']') 
            return true; 
        else
            return false; 
    } 
  
    /* Return true if expression has balanced  
    Parenthesis */
    static Boolean areParenthesisBalanced(char[] exp) 
    { 
        /* Declare an empty character stack */
        Stack<char> st = new Stack<char>(); 
  
        /* Traverse the given expression to  
            check matching parenthesis */
        for (int i = 0; i < exp.Length; i++) { 
  
            /*If the exp[i] is a starting  
                parenthesis then push it*/
            if (exp[i] == '{' || exp[i] == '(' || exp[i] == '[') 
                st.Push(exp[i]); 
  
            /* If exp[i] is an ending parenthesis  
                then pop from stack and check if the  
                popped parenthesis is a matching pair*/
            if (exp[i] == '}' || exp[i] == ')' || exp[i] == ']') { 
  
                /* If we see an ending parenthesis without  
                    a pair then return false*/
                if (st.Count == 0) { 
                    return false; 
                } 
  
                /* Pop the top element from stack, if  
                    it is not a pair parenthesis of character  
                    then there is a mismatch. This happens for  
                    expressions like {(}) */
                else if (!isMatchingPair(st.Pop(), exp[i])) { 
                    return false; 
                } 
            } 
        } 
  
        /* If there is something left in expression  
            then there is a starting parenthesis without  
            a closing parenthesis */
  
        if (st.Count == 0) 
            return true; /*balanced*/
        else { /*not balanced*/
            return false; 
        } 
    } 
  
    /* UTILITY FUNCTIONS */
    /*driver program to test above functions*/
    public static void Main(String[] args) 
    { 
        char[] exp = { '{', '(', ')', '}', '[', ']' }; 
        if (areParenthesisBalanced(exp)) 
            Console.WriteLine("Balanced "); 
        else
            Console.WriteLine("Not Balanced "); 
    } 
} 
  
// This code is contributed by 29AjayKumar 

Output:

Balanced

Time Complexity: O(n)
Auxiliary Space: O(n) for stack.

Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

C

Java

Python3

C#

Recommended Posts: