Approach : Using a Stack

#include <iostream>
#include <stack>
#include <unordered_map>

using namespace std;

string is_balanced(const string& s)
{
    // Initialize an empty stack to keep track of opening
    // brackets
    stack<char> stack;

    // A map to associate closing brackets with their
    // corresponding opening brackets
    unordered_map<char, char> bracket_map
        = { { ')', '(' }, { '}', '{' }, { ']', '[' } };

    // Traverse each character in the string
    for (char chr : s) {
        if (bracket_map.find(chr) == bracket_map.end()) {
            // If the character is an opening bracket, push
            // it onto the stack
            stack.push(chr);
        }
        else {
            // If the character is a closing bracket
            if (stack.empty()
                || stack.top() != bracket_map[chr]) {
                // Check if the stack is empty or the top of
                // the stack does not match the
                // corresponding opening bracket
                return "No"; // The brackets are not
                             // balanced
            }
            stack.pop();
        }
    }

    // If the stack is empty, all opening brackets had a
    // matching closing bracket in the correct order If the
    // stack is not empty, there are unmatched opening
    // brackets
    return stack.empty() ? "Yes" : "No";
}

// Example usage
int main()
{
    cout << is_balanced("(()[]") << endl; // Output: No
    cout << is_balanced("))(({}{") << endl; // Output: No

    return 0;
}

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