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





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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

#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;
    }
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 ");
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up