Check for balanced with only one type of brackets (original) (raw)

Last Updated : 20 Jun, 2025

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 1:

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
If we encounter an opening parentheses ****(**, increase count by 1
If we encounter a closing parentheses ****)**, decrease count by 1
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 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;

}

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;

}

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

Output

Balanced Not Balanced

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

Approach 2: Using Stack

Declare stack.
Iterate string using for loop charAt() method.
If it is an opening bracket then push it to stack
else if it is closing bracket and stack is empty then return 0.
else continue iterating till the end of the string.
at every step check top element of stack using peek() and pop() element accordingly
end loop C++ `

// Here's the equivalent code in C++ with comments:

#include #include using namespace std;

// function to check if the parentheses in a string are // balanced int check(string str) { stack s; for (int i = 0; i < str.length(); i++) { char c = str[i]; if (c == '(') { s.push('('); } else if (c == ')') { if (s.empty()) { return 0; } else { char p = s.top(); if (p == '(') { s.pop(); } else { return 0; } } } } if (s.empty()) { return 1; } else { return 0; } }

int main() { string str = "()(())()"; if (check(str) == 0) { cout << "Invalid" << endl; } else { cout << "Valid" << endl; } return 0; }

Java

import java.util.*; public class Test {

public static int check(String str)
{
    Stack<Character> s = new Stack();
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        if (c == '(') {
            s.push('(');
        }
        else if (c == ')') {
            if (s.isEmpty()) {
                return 0;
            }
            else {
                char p = s.peek();
                if (p == '(') {
                    s.pop();
                }
                else {
                    return 0;
                }
            }
        }
    }
    if (s.empty()) {
        return 1;
    }
    else {
        return 0;
    }
}

public static void main(String[] args)
{
    String str = "()(())()";
    if (check(str) == 0) {
        System.out.println("Invalid");
    }
    else {
        System.out.println("Valid");
    }
}

}

Python

Function to check if the parentheses in a string are balanced

def check(str): s = [] for c in str: if c == '(': s.append('(') elif c == ')': if len(s) == 0: return 0 else: p = s[-1] if p == '(': s.pop() else: return 0 if len(s) == 0: return 1 else: return 0

str = "()(())()" if check(str) == 0: print("Invalid") else: print("Valid")

C#

using System; using System.Collections.Generic;

public class Program{ // Function to check if a given string of parentheses is balanced or not public static int check(string str){ Stack s = new Stack(); for (int i = 0; i < str.Length; i++){ char c = str[i]; if (c == '('){ s.Push('('); } else if (c == ')'){ if (s.Count == 0){ return 0; } else{ char p = s.Peek(); if (p == '('){ s.Pop(); } else{ return 0; } } } } if (s.Count == 0){ return 1; } else{ return 0; } }

public static void Main(string[] args){ string str = "()(())()"; if (check(str) == 0){ Console.WriteLine("Invalid"); } else{ Console.WriteLine("Valid"); } } }

JavaScript

// Function to check if the parentheses in a string are balanced function check(str) { let s = []; for (let i = 0; i < str.length; i++) { let c = str[i]; if (c === '(') { s.push('('); } else if (c === ')') { if (s.length === 0) { return 0; } else { let p = s[s.length - 1]; if (p === '(') { s.pop(); } else { return 0; } } } } if (s.length === 0) { return 1; } else { return 0; } }

let str = "()(())()"; if (check(str) === 0) { console.log("Invalid"); } else { console.log("Valid"); }

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