Related Articles

# Check if given Parentheses expression is balanced or not

• Difficulty Level : Easy
• Last Updated : 10 Aug, 2020

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up