Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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




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



Last Updated : 12 Sep, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads