# 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   ` `#include ` ` `  `// 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   ` `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`

Output:

```Balanced
Not Balanced
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.