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 code
int main()
{
    string expr = "{()}[]";
  
    // Function call
    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.
            // his 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
}
  
  
// Driver code
int main()
{
    char exp[100] = "{()}[]";
    
    // Function call
    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;
            char check;
            switch (x)
            {
            case ')':
                check = stack.pop();
                if (check == '{' || check == '[')
                    return false;
                break;
  
            case '}':
                check = stack.pop();
                if (check == '(' || check == '[')
                    return false;
                break;
  
            case ']':
                check = stack.pop();
                if (check == '(' || check == '{')
                    return false;
                break;
            }
        }
  
        // Check Empty Stack
        return (stack.isEmpty());
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String expr = "([{}])";
        
        // Function call
        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 = "{()}[]"
      
    # Function call
    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;
        }
    }
  
    
    // Driver code
    public static void Main(String[] args)
    {
        char[] exp = { '{', '(', ')', '}', '[', ']' };
         
        // Function call
        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