# Check if given Parentheses expression is balanced or not

• Difficulty Level : Easy
• Last Updated : 08 Apr, 2022

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`

## Javascript

 ``

Output:

```Balanced
Not Balanced```

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

My Personal Notes arrow_drop_up