Related Articles

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

• Difficulty Level : Easy
• Last Updated : 09 Sep, 2020

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``; `` ` `// 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`
Output:
```Yes
```

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up