# Check for balanced parenthesis without using stack

Given an expression string exp, write a program to examine whether the pairs and the orders of “{“, ”}”, ”(“, ”)”, ”[“, ”]” are correct in exp.

Examples:

```Input : exp = “[()]{}{[()()]()}”
Output : true

Input : exp = “[(])”
Output : false
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

We have discussed a stack based solution. Here we are not allowed to use stack. Looks like this problem cannot be solved without extra space (please see comments at the end). We use recursion to solve the problem.

Below is the implementation of above algorithm:

## C++

 `// CPP program to check if parenthesis are ` `// balanced or not in an expression. ` `#include ` `using` `namespace` `std; ` ` `  `char` `findClosing(``char` `c) ` `{ ` `    ``if` `(c == ``'('``) ` `        ``return` `')'``; ` `    ``if` `(c == ``'{'``) ` `        ``return` `'}'``; ` `    ``if` `(c == ``'['``) ` `        ``return` `']'``; ` `    ``return` `-1; ` `} ` ` `  `// function to check if parenthesis are ` `// balanced. ` `bool` `check(``char` `expr[], ``int` `n) ` `{ ` `    ``// Base cases ` `    ``if` `(n == 0) ` `        ``return` `true``; ` `    ``if` `(n == 1) ` `        ``return` `false``; ` `    ``if` `(expr == ``')'` `|| expr == ``'}'` `|| expr == ``']'``) ` `        ``return` `false``; ` ` `  `    ``// Search for closing bracket for first ` `    ``// opening bracket. ` `    ``char` `closing = findClosing(expr); ` ` `  `    ``// count is used to handle cases like ` `    ``// "((()))".  We basically need to ` `    ``// consider matching closing bracket. ` `    ``int` `i, count = 0; ` `    ``for` `(i = 1; i < n; i++) { ` `        ``if` `(expr[i] == expr) ` `            ``count++; ` `        ``if` `(expr[i] == closing) { ` `            ``if` `(count == 0) ` `                ``break``; ` `            ``count--; ` `        ``} ` `    ``} ` ` `  `    ``// If we did not find a closing ` `    ``// bracket ` `    ``if` `(i == n) ` `        ``return` `false``; ` ` `  `    ``// If closing bracket was next ` `    ``// to open ` `    ``if` `(i == 1) ` `        ``return` `check(expr + 2, n - 2); ` ` `  `    ``// If closing bracket was somewhere ` `    ``// in middle. ` `    ``return` `check(expr + 1, i - 1) && check(expr + i + 1, n - i - 1); ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``char` `expr[] = ``"[(])"``; ` `    ``int` `n = ``strlen``(expr); ` `    ``if` `(check(expr, n)) ` `        ``cout << ``"Balanced"``; ` `    ``else` `        ``cout << ``"Not Balanced"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to check if parenthesis are ` `// balanced or not in an expression. ` `import` `java.util.Arrays; ` ` `  `class` `GFG { ` ` `  `    ``static` `char` `findClosing(``char` `c) ` `    ``{ ` `        ``if` `(c == ``'('``) ` `            ``return` `')'``; ` `        ``if` `(c == ``'{'``) ` `            ``return` `'}'``; ` `        ``if` `(c == ``'['``) ` `            ``return` `']'``; ` `        ``return` `Character.MIN_VALUE; ` `    ``} ` ` `  `    ``// function to check if parenthesis are ` `    ``// balanced. ` `    ``static` `boolean` `check(``char` `expr[], ``int` `n) ` `    ``{ ` `        ``// Base cases ` `        ``if` `(n == ``0``) ` `            ``return` `true``; ` `        ``if` `(n == ``1``) ` `            ``return` `false``; ` `        ``if` `(expr[``0``] == ``')'` `|| expr[``0``] == ``'}'` `|| expr[``0``] == ``']'``) ` `            ``return` `false``; ` ` `  `        ``// Search for closing bracket for first ` `        ``// opening bracket. ` `        ``char` `closing = findClosing(expr[``0``]); ` ` `  `        ``// count is used to handle cases like ` `        ``// "((()))". We basically need to ` `        ``// consider matching closing bracket. ` `        ``int` `i, count = ``0``; ` `        ``for` `(i = ``1``; i < n; i++) { ` `            ``if` `(expr[i] == expr[``0``]) ` `                ``count++; ` `            ``if` `(expr[i] == closing) { ` `                ``if` `(count == ``0``) ` `                    ``break``; ` `                ``count--; ` `            ``} ` `        ``} ` ` `  `        ``// If we did not find a closing ` `        ``// bracket ` `        ``if` `(i == n) ` `            ``return` `false``; ` ` `  `        ``// If closing bracket was next ` `        ``// to open ` `        ``if` `(i == ``1``) ` `            ``return` `check(Arrays.copyOfRange(expr, i + ``1``, n), n - ``2``); ` `        ``// If closing bracket was somewhere ` `        ``// in middle. ` `        ``return` `check(Arrays.copyOfRange(expr, ``1``, n), i - ``1``) && check(Arrays.copyOfRange(expr, (i + ``1``), n), n - i - ``1``); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``char` `expr[] = ``"[(])"``.toCharArray(); ` `        ``int` `n = expr.length; ` `        ``if` `(check(expr, n)) ` `            ``System.out.println(``"Balanced"``); ` `        ``else` `            ``System.out.println(``"Not Balanced"``); ` `    ``} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python3 program to check if parenthesis are ` `# balanced or not in an expression. ` `def` `findClosing(c): ` `    ``if` `c ``=``=` `'('``: ` `        ``return` `')'` `    ``elif` `c ``=``=` `'{'``: ` `        ``return` `'}'` `    ``elif` `c ``=``=` `'['``: ` `        ``return` `']'` `    ``return` `-``1` ` `  `# function to check if parenthesis  ` `# are balanced. ` `def` `check(expr, n): ` ` `  `    ``# Base cases ` `    ``if` `n ``=``=` `0``: ` `        ``return` `True` `    ``if` `n ``=``=` `1``: ` `        ``return` `False` `    ``if` `expr[``0``] ``=``=` `')'` `or` `\ ` `       ``expr[``0``] ``=``=` `'}'` `or` `expr[``0``] ``=``=` `']'``: ` `        ``return` `False` ` `  `    ``# Search for closing bracket for first ` `    ``# opening bracket. ` `    ``closing ``=` `findClosing(expr[``0``]) ` ` `  `    ``# count is used to handle cases like ` `    ``# "((()))". We basically need to ` `    ``# consider matching closing bracket. ` `    ``i ``=` `-``1` `    ``count ``=` `0` `    ``for` `i ``in` `range``(``1``, n): ` `        ``if` `expr[i] ``=``=` `expr[``0``]: ` `            ``count ``+``=` `1` `        ``if` `expr[i] ``=``=` `closing: ` `            ``if` `count ``=``=` `0``: ` `                ``break` `            ``count ``-``=` `1` ` `  `    ``# If we did not find a closing ` `    ``# bracket ` `    ``if` `i ``=``=` `n: ` `        ``return` `False` ` `  `    ``# If closing bracket was next ` `    ``# to open ` `    ``if` `i ``=``=` `1``: ` `        ``return` `check(expr[``2``:], n ``-` `2``) ` ` `  `    ``# If closing bracket was somewhere ` `    ``# in middle. ` `    ``return` `check(expr[``1``:], i ``-` `1``) ``and` `\ ` `           ``check(expr[i ``+` `1``:], n ``-` `i ``-` `1``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``expr ``=` `"[(])"` `    ``n ``=` `len``(expr) ` ` `  `    ``if` `check(expr, n): ` `        ``print``(``"Balanced"``) ` `    ``else``: ` `        ``print``(``"Not Balanced"``) ` ` `  `# This code is conributed by ` `# sanjeev2552 `

Output:

```Not Balanced
```

The above solution is very inefficient compared to stack based solution. This seems to only useful for recursion practice problems.

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 :

3

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