# 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; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `    ``static` `String s = ``"[[]][]()"``; ` `    ``static` `int` `count = ``0``; ` `    ``static` `int` `i = ``0``; ` `    ``static` `int` `j = -``1``; ` ` `  `static` `int` `helperFunc(``char` `tocom) ` `{ ` `    ``count--; ` `    ``char` `temp = s.charAt(j); ` `    ``if` `(j > -``1` `&& temp == tocom)  ` `    ``{ ` `        ``s = s.replace(s.charAt(i),``'#'``); ` `        ``s = s.replace(s.charAt(j),``'#'``); ` `        ``temp = s.charAt(j); ` `        ``while` `(j >= ``0` `&& temp == ``'#'``) ` `            ``j--; ` `        ``i++; ` `        ``return` `1``; ` `    ``} ` `    ``else` `        ``return` `0``; ` `} ` ` `  `// Function that returns true if s is a ` `// valid balanced bracket string ` `static` `boolean` `isValid() ` `{ ` ` `  `    ``// Empty string is considered balanced ` `    ``if` `(s.length() == ``0``) ` `        ``return` `true``; ` ` `  `    ``else` `{ ` `        ``int` `result; ` `        ``while` `(i < s.length()) ` `        ``{ ` `            ``char` `temp = s.charAt(i); ` `            ``if``(temp==``'}'``) ` `            ``{ ` `                ``result = helperFunc(``'{'``); ` `                ``if` `(result == ``0``) ` `                ``{ ` `                    ``return` `false``; ` `                ``} ` `            ``} ` `            ``else` `if``(temp == ``')'``) ` `            ``{ ` `                ``result = helperFunc(``'('``); ` `                ``if` `(result == ``0``) ` `                ``{ ` `                    ``return` `false``; ` `                ``} ` `            ``} ` ` `  `            ``else` `if``(temp == ``']'``) ` `            ``{ ` `                ``result = helperFunc(``'['``); ` `                ``if` `(result == ``0``)  ` `                ``{ ` `                    ``return` `false``; ` `                ``} ` `            ``} ` `                 `  `            ``else` `            ``{ ` `                ``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``; ` `    ``} ` `} ` ` `  `// 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 ` ` `  ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``if` `(isValid()) ` `    ``System.out.println(``"No"``); ` `    ``else` `    ``System.out.println(``"Yes"``); ` `} ` ` `  `} ` ` `  `// This code is contributed by Surendra_Gangwar `

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

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.