Related Articles

Related Articles

Check if given Parentheses expression is balanced or not
  • Difficulty Level : Medium
  • Last Updated : 10 Aug, 2020

Given a string str of length N, consisting of ‘(‘ and ‘)‘ only, the task is to check whether it is balanced or not.
Examples:

Input: str = “((()))()()” 
Output: Balanced

Input: str = “())((())” 
Output: Not Balanced 
 

Approach: 

  • Declare a Flag variable which denotes expression is balanced or not.
  • Initialise Flag variable with true and Count variable with 0.
  • Traverse through the given expression
    1. If we encounter an opening parentheses (, increase count by 1
    2. If we encounter a closing parentheses ), decrease count by 1
    3. If Count becomes negative at any point, then expression is said to be not balanced, 
      so mark Flag as false and break from loop.
  • After traversing the expression, if Count is not equal to 0, 
    it means the expression is not balanced so mark Flag as false.
  • Finally, if Flag is true, expression is balanced else not balanced.

Below is the implementation of the above approach:



C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program of the above approach
#include <stdbool.h> 
#include <stdio.h>
  
// Function to check if
// parentheses are balanced
bool isBalanced(char exp[])
{
    // Initialising Variables
    bool flag = true;
    int count = 0;
  
    // Traversing the Expression
    for (int i = 0; exp[i] != '\0'; i++) {
  
        if (exp[i] == '(') {
            count++;
        }
        else {
            // It is a closing parenthesis
            count--;
        }
        if (count < 0) {
            // This means there are
            // more Closing parenthesis
            // than opening ones
            flag = false;
            break;
        }
    }
  
    // If count is not zero,
    // It means there are more
    // opening parenthesis
    if (count != 0) {
        flag = false;
    }
  
    return flag;
}
  
// Driver code
int main()
{
    char exp1[] = "((()))()()";
  
    if (isBalanced(exp1))
        printf("Balanced \n");
    else
        printf("Not Balanced \n");
  
    char exp2[] = "())((())";
  
    if (isBalanced(exp2))
        printf("Balanced \n");
    else
        printf("Not Balanced \n");
  
    return 0;
}

chevron_right


C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach.
  
#include <bits/stdc++.h> 
using namespace std;
  
// Function to check
// if parentheses are balanced
bool isBalanced(string exp)
{
  
    // Initialising Variables
    bool flag = true;
    int count = 0;
  
    // Traversing the Expression
    for (int i = 0; i < exp.length(); i++) {
  
        if (exp[i] == '(') {
            count++;
        }
        else {
  
            // It is a closing parenthesis
            count--;
        }
        if (count < 0) {
  
            // This means there are
            // more Closing parenthesis
            // than opening ones
            flag = false;
            break;
        }
    }
  
    // If count is not zero,
    // It means there are
    // more opening parenthesis
    if (count != 0) {
        flag = false;
    }
  
    return flag;
}
  
// Driver code
int main()
{
    string exp1 = "((()))()()";
  
    if (isBalanced(exp1))
        cout << "Balanced \n";
    else
        cout << "Not Balanced \n";
  
    string exp2 = "())((())";
  
    if (isBalanced(exp2))
        cout << "Balanced \n";
    else
        cout << "Not Balanced \n";
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach. 
class GFG{
  
// Function to check 
// if parentheses are balanced 
public static boolean isBalanced(String exp) 
{
      
    // Initialising variables 
    boolean flag = true
    int count = 0
      
    // Traversing the expression 
    for(int i = 0; i < exp.length(); i++)
    
        if (exp.charAt(i) == '('
        
            count++; 
        
        else
        
              
            // It is a closing parenthesis 
            count--; 
        
        if (count < 0)
        
              
            // This means there are 
            // more Closing parenthesis 
            // than opening ones 
            flag = false
            break
        
    
      
    // If count is not zero, 
    // It means there are 
    // more opening parenthesis 
    if (count != 0
    
        flag = false
    }
    return flag; 
  
// Driver code
public static void main(String[] args)
{
    String exp1 = "((()))()()"
      
    if (isBalanced(exp1)) 
        System.out.println("Balanced");
    else
        System.out.println("Not Balanced");
      
    String exp2 = "())((())"
      
    if (isBalanced(exp2)) 
        System.out.println("Balanced");
    else
        System.out.println("Not Balanced");
}
}
  
// This code is contributed by divyeshrabadiya07

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to check if 
# parenthesis are balanced
def isBalanced(exp):
  
    # Initialising Variables
    flag = True
    count = 0
  
    # Traversing the Expression
    for i in range(len(exp)):
        if (exp[i] == '('):
            count += 1
        else:
              
            # It is a closing parenthesis
            count -= 1
  
        if (count < 0):
  
            # This means there are 
            # more closing parenthesis 
            # than opening
            flag = False
            break
  
    # If count is not zero , 
    # it means there are more 
    # opening parenthesis
    if (count != 0):
        flag = False
  
    return flag
  
# Driver code
if __name__ == '__main__':
      
  
    exp1 = "((()))()()"
  
    if (isBalanced(exp1)):
        print("Balanced")
    else:
        print("Not Balanced")
  
    exp2 = "())((())"
  
    if (isBalanced(exp2)):
        print("Balanced")
    else:
        print("Not Balanced")
  
# This code is contributed by himanshu77

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach. 
using System;
  
class GFG{
  
// Function to check 
// if parentheses are balanced 
public static bool isBalanced(String exp) 
{
      
    // Initialising variables 
    bool flag = true
    int count = 0; 
      
    // Traversing the expression 
    for(int i = 0; i < exp.Length; i++)
    
        if (exp[i] == '('
        
            count++; 
        
        else
        
              
            // It is a closing parenthesis 
            count--; 
        
        if (count < 0)
        
              
            // This means there are 
            // more Closing parenthesis 
            // than opening ones 
            flag = false
            break
        
    
      
    // If count is not zero, 
    // It means there are 
    // more opening parenthesis 
    if (count != 0) 
    
        flag = false
    }
    return flag; 
  
// Driver code
public static void Main(String[] args)
{
    String exp1 = "((()))()()"
      
    if (isBalanced(exp1)) 
        Console.WriteLine("Balanced");
    else
        Console.WriteLine("Not Balanced");
      
    String exp2 = "())((())"
      
    if (isBalanced(exp2)) 
        Console.WriteLine("Balanced");
    else
        Console.WriteLine("Not Balanced");
}
}
  
// This code is contributed by Amit Katiyar

chevron_right


Output: 

Balanced 
Not Balanced

Time complexity: O(N) 
Auxiliary Space: O(1)
 

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
Recommended Articles
Page :