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

Last Updated : 12 Sep, 2022

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

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

## C#

 `// C# implementation of the approach` `using` `System;`   `class` `GFG{`   `static` `string` `s = ``"[[]][]()"``;` `static` `int` `count = 0;` `static` `int` `i = 0;` `static` `int` `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` `static` `int` `helperFunc(``char` `tocom)` `{` `    ``count--;` `    ``char` `temp = s[j];` `    `  `    ``if` `(j > -1 && temp == tocom) ` `    ``{` `        ``s = s.Replace(s[i],``'#'``);` `        ``s = s.Replace(s[j],``'#'``);` `        `  `        ``temp = s[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` `bool` `isValid()` `{`   `    ``// Empty string is considered balanced` `    ``if` `(s.Length == 0)` `        ``return` `true``;`   `    ``else` `    ``{` `        ``int` `result;` `         ``while` `(i < s.Length) ` `        ``{ ` `            ``char` `temp = s[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``;` `    ``}` `}`   `// Driver code` `public` `static` `void` `Main(``string` `[]args)` `{` `    ``if` `(isValid())` `    ``{` `        ``Console.Write(``"No"``);` `    ``}` `    ``else` `    ``{` `        ``Console.Write(``"Yes"``);` `    ``}` `}` `}`   `// This code is contributed by rutvik_56`

## Javascript

 `// JavaScript implementation of the approach `   `// Increments for opening bracket and ` `// decrements for closing bracket ` `var` `i = 0; ` `var` `count = 0; ` `var` `j = -1; ` `var` `s;`   `// 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 ` `function` `helperFunc(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 ` `function` `isValid(str) ` `{ ` `    ``s = str.split(``""``)` `    `  `    ``// Empty string is considered balanced ` `    ``if` `(s.length == 0) ` `        ``return` `true``; `   `    ``else` `{ ` `        ``let result; ` `        ``while` `(i < s.length) { ` `            ``switch` `(s[i]) { ` `            ``case` `'}'``: ` `                ``result = helperFunc(``'{'``); ` `                ``if` `(result == 0) { ` `                    ``return` `false``; ` `                ``} ` `                ``break``; `   `            ``case` `')'``: ` `                ``result = helperFunc(``'('``); ` `                ``if` `(result == 0) { ` `                    ``return` `false``; ` `                ``} ` `                ``break``; `   `            ``case` `']'``: ` `                ``result = helperFunc(``'['``); ` `                ``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 ` `let str = ``"[[]][]()"``; `   `if` `(isValid(str)) ` `    ``console.log(``"Yes"``); ` `else` `    ``console.log(``"No"``); `   `// This code is contributed by phasing17`

Output:

`Yes`

Time complexity: O(N^2) where N is length of input expression string

Auxiliary Space: O(1)

Share your thoughts in the comments