Check for balanced parenthesis without using stack

Given an expression string exp, write a program to examine whether the pairs and the orders of “{“, ”}”, ”(“, ”)”, ”[“, ”]” are correct in exp.

Examples:

Input : exp = “[()]{}{[()()]()}”
Output : true

Input : exp = “[(])”
Output : false

We have discussed a stack based solution. Here we are not allowed to use stack. Looks like this problem cannot be solved without extra space (please see comments at the end). We use recursion to solve the problem.



Below is the implementation of above algorithm:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to check if parenthesis are
// balanced or not in an expression.
#include <bits/stdc++.h>
using namespace std;
  
char findClosing(char c)
{
    if (c == '(')
        return ')';
    if (c == '{')
        return '}';
    if (c == '[')
        return ']';
    return -1;
}
  
// function to check if parenthesis are
// balanced.
bool check(char expr[], int n)
{
    // Base cases
    if (n == 0)
        return true;
    if (n == 1)
        return false;
    if (expr[0] == ')' || expr[0] == '}' || expr[0] == ']')
        return false;
  
    // Search for closing bracket for first
    // opening bracket.
    char closing = findClosing(expr[0]);
  
    // count is used to handle cases like
    // "((()))".  We basically need to
    // consider matching closing bracket.
    int i, count = 0;
    for (i = 1; i < n; i++) {
        if (expr[i] == expr[0])
            count++;
        if (expr[i] == closing) {
            if (count == 0)
                break;
            count--;
        }
    }
  
    // If we did not find a closing
    // bracket
    if (i == n)
        return false;
  
    // If closing bracket was next
    // to open
    if (i == 1)
        return check(expr + 2, n - 2);
  
    // If closing bracket was somewhere
    // in middle.
    return check(expr + 1, i - 1) && check(expr + i + 1, n - i - 1);
}
  
// Driver program to test above function
int main()
{
    char expr[] = "[(])";
    int n = strlen(expr);
    if (check(expr, n))
        cout << "Balanced";
    else
        cout << "Not Balanced";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to check if parenthesis are
// balanced or not in an expression.
import java.util.Arrays;
  
class GFG {
  
    static char findClosing(char c)
    {
        if (c == '(')
            return ')';
        if (c == '{')
            return '}';
        if (c == '[')
            return ']';
        return Character.MIN_VALUE;
    }
  
    // function to check if parenthesis are
    // balanced.
    static boolean check(char expr[], int n)
    {
        // Base cases
        if (n == 0)
            return true;
        if (n == 1)
            return false;
        if (expr[0] == ')' || expr[0] == '}' || expr[0] == ']')
            return false;
  
        // Search for closing bracket for first
        // opening bracket.
        char closing = findClosing(expr[0]);
  
        // count is used to handle cases like
        // "((()))". We basically need to
        // consider matching closing bracket.
        int i, count = 0;
        for (i = 1; i < n; i++) {
            if (expr[i] == expr[0])
                count++;
            if (expr[i] == closing) {
                if (count == 0)
                    break;
                count--;
            }
        }
  
        // If we did not find a closing
        // bracket
        if (i == n)
            return false;
  
        // If closing bracket was next
        // to open
        if (i == 1)
            return check(Arrays.copyOfRange(expr, i + 1, n), n - 2);
        // If closing bracket was somewhere
        // in middle.
        return check(Arrays.copyOfRange(expr, 1, n), i - 1) && check(Arrays.copyOfRange(expr, (i + 1), n), n - i - 1);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        char expr[] = "[(])".toCharArray();
        int n = expr.length;
        if (check(expr, n))
            System.out.println("Balanced");
        else
            System.out.println("Not Balanced");
    }
}
  
/* This code contributed by PrinciRaj1992 */

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to check if parenthesis are
# balanced or not in an expression.
def findClosing(c):
    if c == '(':
        return ')'
    elif c == '{':
        return '}'
    elif c == '[':
        return ']'
    return -1
  
# function to check if parenthesis 
# are balanced.
def check(expr, n):
  
    # Base cases
    if n == 0:
        return True
    if n == 1:
        return False
    if expr[0] == ')' or \
       expr[0] == '}' or expr[0] == ']':
        return False
  
    # Search for closing bracket for first
    # opening bracket.
    closing = findClosing(expr[0])
  
    # count is used to handle cases like
    # "((()))". We basically need to
    # consider matching closing bracket.
    i = -1
    count = 0
    for i in range(1, n):
        if expr[i] == expr[0]:
            count += 1
        if expr[i] == closing:
            if count == 0:
                break
            count -= 1
  
    # If we did not find a closing
    # bracket
    if i == n:
        return False
  
    # If closing bracket was next
    # to open
    if i == 1:
        return check(expr[2:], n - 2)
  
    # If closing bracket was somewhere
    # in middle.
    return check(expr[1:], i - 1) and \
           check(expr[i + 1:], n - i - 1)
  
# Driver Code
if __name__ == "__main__":
    expr = "[(])"
    n = len(expr)
  
    if check(expr, n):
        print("Balanced")
    else:
        print("Not Balanced")
  
# This code is conributed by
# sanjeev2552

chevron_right


Output:

Not Balanced

The above solution is very inefficient compared to stack based solution. This seems to only useful for recursion practice problems.



My Personal Notes arrow_drop_up

A Programmer and A Machine learning Enthusiast

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.