Open in App
Not now

Check if given Parentheses expression is balanced or not

• Difficulty Level : Easy
• Last Updated : 29 Mar, 2023

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 ` `#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)

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

My Personal Notes arrow_drop_up
Related Articles