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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


Output:

Yes



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.