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

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:
Open brackets must be closed by the same type of brackets.Open brackets must be closed in the correct order.
Open brackets must be closed by the same type of brackets.
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 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++
Java
Python3
C#
// C++ implementation of the approach #include <iostream> 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 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 implementation of the approach   # These are defined as global because they # are passed by reference count = 0i = 0j = -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# implementation of the approachusing 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 0static 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 stringstatic 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 codepublic static void Main(string []args){    if (isValid())    {        Console.Write("No");    }    else    {        Console.Write("Yes");    }}}  // This code is contributed by rutvik_56
Yes

sanjeev2552
SURENDRA_GANGWAR
rutvik_56
Constructive Algorithms
Mathematical
Strings
Strings
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Program to print prime numbers from 1 to N.
Segment Tree | Set 1 (Sum of given range)
Modular multiplicative inverse
Count all possible paths from top left to bottom right of a mXn matrix
Fizz Buzz Implementation
Write a program to reverse an array or string
Reverse a string in Java
Longest Common Subsequence | DP-4
Check for Balanced Brackets in an expression (well-formedness) using Stack
Python program to check if a string is palindrome or not