 Open in App
Not now

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

• Difficulty Level : Medium
• 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)

My Personal Notes arrow_drop_up