Check for balanced with only one type of brackets

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

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 <iostream>
#include <stack>
using namespace std;

// function to check if the parentheses in a string are
// balanced
int check(string str)
{
    stack<char> 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<char> s = new Stack<char>();
    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");
}

Output
Valid

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

Comment
Article Tags:
DSA

Explore