Check if given Parentheses expression is balanced or not

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

Javascript

<script>

// JavaScript program for the above approach

// Function to check if
// parenthesis are balanced
function isBalanced(exp){

    // Initialising Variables
    let flag = true
    let count = 0

    // Traversing the Expression
    for(let i=0;i<exp.length;i++){
        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

let exp1 = "((()))()()"

if (isBalanced(exp1))
    document.write("Balanced","</br>")
else
    document.write("Not Balanced","</br>")

let exp2 = "())((())"

if (isBalanced(exp2))
    document.write("Balanced","</br>")
else
    document.write("Not Balanced","</br>")

// This code is contributed by shinjanpatra

</script>

Output:

Balanced 
Not Balanced

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