Check for balanced parenthesis without using stack - GeeksforGeeks

29 Aug, 2021
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 the 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 the above algorithm:  
C++
Java
Python3
C#
Javascript
// 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 functionint main(){    char expr[] = "[(])";    int n = strlen(expr);    if (check(expr, n))        cout << "Balanced";    else        cout << "Not Balanced";    return 0;}
// 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 */
# 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 Codeif __name__ == "__main__":    expr = "[(])"    n = len(expr)     if check(expr, n):        print("Balanced")    else:        print("Not Balanced") # This code is contributed by# sanjeev2552
// C# program to check// if parenthesis are// balanced or not in// an expression.using System;class GFG{     static char[] copyOfRange (char[] src,                           int start,                           int end){  int len = end - start;  char[] dest = new char[len];  Array.Copy(src, start,             dest, 0, len);  return dest;} static char findClosing(char c){  if (c == '(')    return ')';  if (c == '{')    return '}';  if (c == '[')    return ']';  return char.MinValue;} // Function to check if// parenthesis are balanced.static 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(copyOfRange(expr,                             i + 1, n),                              n - 2);  // If closing bracket  // was somewhere in middle.  return check(copyOfRange(expr, 1, n),                           i - 1) &&         check(copyOfRange(expr, (i + 1),                           n), n - i - 1);} // Driver codepublic static void Main(String[] args){  char []expr = "[(])".ToCharArray();  int n = expr.Length;  if (check(expr, n))    Console.WriteLine("Balanced");  else    Console.WriteLine("Not Balanced");}} // This code is contributed by gauravrajput1
<script> // Javascript program to check if parenthesis are// balanced or not in an expression. function findClosing(c){    if (c == '(')        return ')';    if (c == '{')        return '}';    if (c == '[')        return ']';    return -1;} // function to check if parenthesis are// balanced.function check(expr, 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.    var closing = findClosing(expr[0]);     // count is used to handle cases like    // "((()))".  We basically need to    // consider matching closing bracket.    var 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 functionvar expr = "[(])";var n = expr.length;if (check(expr, n))    document.write( "Balanced");else    document.write( "Not Balanced"); // This code is contributed by itsok.</script>
Not Balanced
 
The above solution is very inefficient compared to the stack-based solution. This seems to only useful for recursion practice problems. 
princiraj1992
SalmanKhan13
sanjeev2552
GauravRajput1
itsok
surinderdawra388
Amazon
expression-evaluation
Recursion
Stack
Amazon
Recursion
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Recursive Insertion Sort
Decimal to binary number using recursion
Sum of natural numbers using recursion
Practice Questions for Recursion | Set 1
Recursively Reversing a linked list (A simple implementation)
Stack Data Structure (Introduction and Program)
Stack Class in Java
Stack in Python
Check for Balanced Brackets in an expression (well-formedness) using Stack
Stack | Set 2 (Infix to Postfix)