Open In App

Check for balanced with only one type of brackets

Last Updated : 20 Jun, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

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)


Next Article
Valid Parentheses in an Expression
author
7maestro
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox