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


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.



Improved By : sanjeev2552