# Check for balanced parentheses in an expression | O(1) space | O(N^2) time complexity

Given a string str containing characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[‘ and ‘]’, the task is to determine if brackets are balanced or not.
Brackets are balanced if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.

Examples:

Input: str = “(())[]”
Output: Yes

Input: str = “))(({}{”
Output: No

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• Keep two variables i and j to keep track of two brackets to be compared.
• Maintain a count whose value increments on encountering opening bracket and decrements on encountering a closing bracket.
• Set j = i, i = i + 1 and counter++ when opening brackets are encountered.
• When Closing brackets are encountered decrement count and compare brackets at i and j,
• If brackets at i and j are a match, then substitute ‘#’ in string at ith and jth position. Increment i and decrement j until non ‘#’ value is encountered or j ≥ 0.
• If brackets at i and j are not a match then return false.
• If count != 0 then return false.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// This helper function is called whenever ` `// closing bracket is encountered. ` `// Hence count is decremented ` `// j and i points to opening and closing ` `// brackets to be matched respectively ` `// If brackets at i and j is a match ` `// replace them with "#" character and decrement j ` `// to point next opening bracket to * be matched ` `// Similarly, increment i to point to next closing ` `// bracket to be matched ` `// If j is out of bound or brackets did not match return 0 ` `bool` `helperFunc(``int``& count, string& s, ``int``& i, ``int``& j, ``char` `tocom) ` `{ ` `    ``count--; ` `    ``if` `(j > -1 && s[j] == tocom) { ` `        ``s[i] = ``'#'``; ` `        ``s[j] = ``'#'``; ` `        ``while` `(j >= 0 && s[j] == ``'#'``) ` `            ``j--; ` `        ``i++; ` `        ``return` `1; ` `    ``} ` `    ``else` `        ``return` `0; ` `} ` ` `  `// Function that returns true if s is a ` `// valid balanced bracket string ` `bool` `isValid(string s) ` `{ ` ` `  `    ``// Empty string is considered balanced ` `    ``if` `(s.length() == 0) ` `        ``return` `true``; ` ` `  `    ``else` `{ ` `        ``int` `i = 0; ` ` `  `        ``// Increments for opening bracket and ` `        ``// decrements for closing bracket ` `        ``int` `count = 0; ` `        ``int` `j = -1; ` `        ``bool` `result; ` `        ``while` `(i < s.length()) { ` `            ``switch` `(s[i]) { ` `            ``case` `'}'``: ` `                ``result = helperFunc(count, s, i, j, ``'{'``); ` `                ``if` `(result == 0) { ` `                    ``return` `false``; ` `                ``} ` `                ``break``; ` ` `  `            ``case` `')'``: ` `                ``result = helperFunc(count, s, i, j, ``'('``); ` `                ``if` `(result == 0) { ` `                    ``return` `false``; ` `                ``} ` `                ``break``; ` ` `  `            ``case` `']'``: ` `                ``result = helperFunc(count, s, i, j, ``'['``); ` `                ``if` `(result == 0) { ` `                    ``return` `false``; ` `                ``} ` `                ``break``; ` ` `  `            ``default``: ` `                ``j = i; ` `                ``i++; ` `                ``count++; ` `            ``} ` `        ``} ` ` `  `        ``// count != 0 indicates unbalanced parentheses ` `        ``// this check is required to handle cases where ` `        ``// count of opening brackets > closing brackets ` `        ``if` `(count != 0) ` `            ``return` `false``; ` ` `  `        ``return` `true``; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"[[]][]()"``; ` ` `  `    ``if` `(isValid(str)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` ` `  `    ``return` `0; ` `} `

## Python3

 `# Python3 implementation of the approach ` ` `  `# These are defined as global because they ` `# are passed by reference ` `count ``=` `0` `i ``=` `0` `j ``=` `-``1` ` `  `# This helper function is called whenever ` `# closing bracket is encountered. ` `# Hence count is decremented ` `# j and i points to opening and closing ` `# brackets to be matched respectively ` `# If brackets at i and j is a match ` `# replace them with "#" character and decrement j ` `# to point next opening bracket to * be matched ` `# Similarly, increment i to point to next closing ` `# bracket to be matched ` `# If j is out of bound or brackets  ` `# did not match return 0 ` `def` `helperFunc(s, tocom): ` `    ``global` `i, j, count ` `    ``count ``-``=` `1` `    ``if` `j > ``-``1` `and` `s[j] ``=``=` `tocom: ` `        ``s[i] ``=` `'#'` `        ``s[j] ``=` `'#'` `        ``while` `j >``=` `0` `and` `s[j] ``=``=` `'#'``: ` `            ``j ``-``=` `1` `        ``i ``+``=` `1` `        ``return` `1` `    ``else``: ` `        ``return` `0` ` `  `# Function that returns true if s is a ` `# valid balanced bracket string ` `def` `isValid(s): ` `    ``global` `i, j, count ` ` `  `    ``# Empty string is considered balanced ` `    ``if` `len``(s) ``=``=` `0``: ` `        ``return` `True` `    ``else``: ` ` `  `        ``# Increments for opening bracket and ` `        ``# decrements for closing bracket ` `        ``result ``=` `False` `        ``while` `i < ``len``(s): ` `            ``if` `s[i] ``=``=` `'}'``: ` `                ``result ``=` `helperFunc(s, ``'{'``) ` `                ``if` `result ``=``=` `0``: ` `                    ``return` `False` `            ``elif` `s[i] ``=``=` `')'``: ` `                ``result ``=` `helperFunc(s, ``'('``) ` `                ``if` `result ``=``=` `0``: ` `                    ``return` `False` `            ``elif` `s[i] ``=``=` `']'``: ` `                ``result ``=` `helperFunc(s, ``'['``) ` `                ``if` `result ``=``=` `0``: ` `                    ``return` `False` `            ``else``: ` `                ``j ``=` `i ` `                ``i ``+``=` `1` `                ``count ``+``=` `1` ` `  `        ``# count != 0 indicates unbalanced parentheses ` `        ``# this check is required to handle cases where ` `        ``# count of opening brackets > closing brackets ` `        ``if` `count !``=` `0``: ` `            ``return` `False` `        ``return` `True` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``string ``=` `"[[]][]()"` `    ``string ``=` `list``(string) ` ` `  `    ``print``(``"Yes"``) ``if` `isValid(string) ``else` `print``(``"No"``) ` ` `  `# This code is contributed by ` `# sanjeev2552 `

Output:

```Yes
```

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.

Improved By : sanjeev2552