Check if given Parentheses expression is balanced or not

Difficulty Level : Easy
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

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

C++

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

Java

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

Python3

# 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

C#

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

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. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes