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 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)
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" );
}
}
} |
Python3
# 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)
Recommended Articles