Open In App

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