# Check for balanced parentheses in an expression

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

Example:

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

Input: exp = “[(])”
Output: Not Balanced ## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Algorithm:

• Declare a character stack S.
• Now traverse the expression string exp.
1. If the current character is a starting bracket (‘(‘ or ‘{‘ or ‘[‘) then push it to stack.
2. If the current character is a closing bracket (‘)’ or ‘}’ or ‘]’) then pop from stack and if the popped character is the matching starting bracket then fine else parenthesis are not balanced.
• After complete traversal, if there is some starting bracket left in stack then “not balanced”

Below image is a dry run of the above approach: Below is the implementation of the above approach:

## C++

 `// CPP program to check for balanced parenthesis. ` `#include ` `using` `namespace` `std; ` ` `  `// function to check if paranthesis are balanced ` `bool` `areParanthesisBalanced(string expr) ` `{ ` `    ``stack<``char``> s; ` `    ``char` `x; ` ` `  `    ``// Traversing the Expression ` `    ``for` `(``int` `i=0; i

## C

 `#include ` `#include ` `#define bool int ` ` `  `/* structure of a stack node */` `struct` `sNode ` `{ ` `   ``char` `data; ` `   ``struct` `sNode *next; ` `}; ` ` `  `/* Function to push an item to stack*/` `void` `push(``struct` `sNode** top_ref, ``int` `new_data); ` ` `  `/* Function to pop an item from stack*/` `int` `pop(``struct` `sNode** top_ref); ` ` `  `/* Returns 1 if character1 and character2 are matching left ` `   ``and right Parenthesis */` `bool` `isMatchingPair(``char` `character1, ``char` `character2) ` `{ ` `   ``if` `(character1 == ``'('` `&& character2 == ``')'``) ` `     ``return` `1; ` `   ``else` `if` `(character1 == ``'{'` `&& character2 == ``'}'``) ` `     ``return` `1; ` `   ``else` `if` `(character1 == ``'['` `&& character2 == ``']'``) ` `     ``return` `1; ` `   ``else` `     ``return` `0; ` `} ` ` `  `/*Return 1 if expression has balanced Parenthesis */` `bool` `areParenthesisBalanced(``char` `exp``[]) ` `{ ` `   ``int` `i = 0; ` ` `  `   ``/* Declare an empty character stack */` `   ``struct` `sNode *stack = NULL; ` ` `  `   ``/* Traverse the given expression to check matching parenthesis */` `   ``while` `(``exp``[i]) ` `   ``{ ` `      ``/*If the exp[i] is a starting parenthesis then push it*/` `      ``if` `(``exp``[i] == ``'{'` `|| ``exp``[i] == ``'('` `|| ``exp``[i] == ``'['``) ` `        ``push(&stack, ``exp``[i]); ` ` `  `      ``/* If exp[i] is an ending parenthesis then pop from stack and  ` `          ``check if the popped parenthesis is a matching pair*/` `      ``if` `(``exp``[i] == ``'}'` `|| ``exp``[i] == ``')'` `|| ``exp``[i] == ``']'``) ` `      ``{ ` `             `  `          ``/*If we see an ending parenthesis without a pair then return false*/` `         ``if` `(stack == NULL) ` `           ``return` `0;  ` ` `  `         ``/* Pop the top element from stack, if it is not a pair  ` `            ``parenthesis of character then there is a mismatch. ` `            ``This happens for expressions like {(}) */` `         ``else` `if` `( !isMatchingPair(pop(&stack), ``exp``[i]) ) ` `           ``return` `0; ` `      ``} ` `      ``i++; ` `   ``} ` `    `  `   ``/* If there is something left in expression then there is a starting ` `      ``parenthesis without a closing parenthesis */` `   ``if` `(stack == NULL) ` `     ``return` `1; ``/*balanced*/` `   ``else` `     ``return` `0;  ``/*not balanced*/` `}  ` ` `  `/* UTILITY FUNCTIONS */` `/*driver program to test above functions*/` `int` `main() ` `{ ` `  ``char` `exp`` = ``"{()}[]"``; ` `  ``if` `(areParenthesisBalanced(``exp``)) ` `    ``printf``(``"Balanced \n"``); ` `  ``else` `    ``printf``(``"Not Balanced \n"``);   ` `  ``return` `0; ` `}     ` ` `  `/* Function to push an item to stack*/` `void` `push(``struct` `sNode** top_ref, ``int` `new_data) ` `{ ` `  ``/* allocate node */` `  ``struct` `sNode* new_node = ` `            ``(``struct` `sNode*) ``malloc``(``sizeof``(``struct` `sNode)); ` ` `  `  ``if` `(new_node == NULL) ` `  ``{ ` `     ``printf``(``"Stack overflow n"``); ` `     ``getchar``(); ` `     ``exit``(0); ` `  ``}            ` ` `  `  ``/* put in the data  */` `  ``new_node->data  = new_data; ` ` `  `  ``/* link the old list off the new node */` `  ``new_node->next = (*top_ref);   ` ` `  `  ``/* move the head to point to the new node */` `  ``(*top_ref)    = new_node; ` `} ` ` `  `/* Function to pop an item from stack*/` `int` `pop(``struct` `sNode** top_ref) ` `{ ` `  ``char` `res; ` `  ``struct` `sNode *top; ` ` `  `  ``/*If stack is empty then error */` `  ``if` `(*top_ref == NULL) ` `  ``{ ` `     ``printf``(``"Stack overflow n"``); ` `     ``getchar``(); ` `     ``exit``(0); ` `  ``} ` `  ``else` `  ``{ ` `     ``top = *top_ref; ` `     ``res = top->data; ` `     ``*top_ref = top->next; ` `     ``free``(top); ` `     ``return` `res; ` `  ``} ` `} `

## Java

 `// Java program for checking ` `// balanced Parenthesis ` ` `  `public` `class` `BalancedParan  ` `{ ` `    ``static` `class` `stack  ` `    ``{ ` `        ``int` `top=-``1``; ` `        ``char` `items[] = ``new` `char``[``100``]; ` ` `  `        ``void` `push(``char` `x)  ` `        ``{ ` `            ``if` `(top == ``99``)  ` `            ``{ ` `                ``System.out.println(``"Stack full"``); ` `            ``}  ` `            ``else`  `            ``{ ` `                ``items[++top] = x; ` `            ``} ` `        ``} ` ` `  `        ``char` `pop()  ` `        ``{ ` `            ``if` `(top == -``1``)  ` `            ``{ ` `                ``System.out.println(``"Underflow error"``); ` `                ``return` `'\0'``; ` `            ``}  ` `            ``else`  `            ``{ ` `                ``char` `element = items[top]; ` `                ``top--; ` `                ``return` `element; ` `            ``} ` `        ``} ` ` `  `        ``boolean` `isEmpty()  ` `        ``{ ` `            ``return` `(top == -``1``) ? ``true` `: ``false``; ` `        ``} ` `    ``} ` `     `  `    ``/* Returns true if character1 and character2 ` `       ``are matching left and right Parenthesis */` `    ``static` `boolean` `isMatchingPair(``char` `character1, ``char` `character2) ` `    ``{ ` `       ``if` `(character1 == ``'('` `&& character2 == ``')'``) ` `         ``return` `true``; ` `       ``else` `if` `(character1 == ``'{'` `&& character2 == ``'}'``) ` `         ``return` `true``; ` `       ``else` `if` `(character1 == ``'['` `&& character2 == ``']'``) ` `         ``return` `true``; ` `       ``else` `         ``return` `false``; ` `    ``} ` `     `  `    ``/* Return true if expression has balanced  ` `       ``Parenthesis */` `    ``static` `boolean` `areParenthesisBalanced(``char` `exp[]) ` `    ``{ ` `       ``/* Declare an empty character stack */` `       ``stack st=``new` `stack(); ` `      `  `       ``/* Traverse the given expression to  ` `          ``check matching parenthesis */` `       ``for``(``int` `i=``0``;i

## Python3

 `# Python3 program to check for ` `# balanced parenthesis.  ` ` `  `# function to check if  ` `# paranthesis are balanced  ` `def` `areParanthesisBalanced(expr) :  ` ` `  `    ``s ``=` `[];  ` ` `  `    ``# Traversing the Expression  ` `    ``for` `i ``in` `range``(``len``(expr)) : ` ` `  `        ``if` `(expr[i] ``=``=` `'('` `or`  `            ``expr[i] ``=``=` `'['` `or` `expr[i] ``=``=` `'{'``) : ` ` `  `            ``# Push the element in the stack  ` `            ``s.append(expr[i]);  ` `            ``continue``;  ` ` `  `        ``# IF current character is not opening  ` `        ``# bracket, then it must be closing.   ` `        ``# So stack cannot be empty at this point.  ` `        ``if` `(``len``(s) ``=``=` `0``) : ` `            ``return` `False``;  ` ` `  `        ``if` `expr[i] ``=``=` `')'` `: ` ` `  `            ``# Store the top element in a  ` `            ``x ``=` `s.pop(); ` `             `  `            ``if` `(x ``=``=` `'{'` `or` `x ``=``=` `'['``) : ` `                ``return` `False``;  ` ` `  `        ``elif` `expr[i] ``=``=` `'}'``:  ` ` `  `            ``# Store the top element in b  ` `            ``x ``=` `s.pop(); ` `             `  `            ``if` `(x ``=``=` `'('` `or` `x ``=``=` `'['``) : ` `                ``return` `False``;  ` `         `  `        ``elif` `x ``=``=` `']'``:  ` ` `  `            ``# Store the top element in c  ` `            ``x ``=` `s.pop(); ` `             `  `            ``if` `(x ``=``=``'('` `or` `x ``=``=` `'{'``) : ` `                ``return` `False``;  ` ` `  `    ``# Check Empty Stack  ` `    ``if` `len``(s) : ` `        ``return` `True` `    ``else` `: ` `        ``return` `False` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``expr ``=` `"{()}[]"``;  ` ` `  `    ``if` `(areParanthesisBalanced(expr)) : ` `        ``print``(``"Balanced"``);  ` `    ``else` `: ` `        ``print``(``"Not Balanced"``);  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# program for checking ` `// balanced Parenthesis ` `using` `System; ` `using` `System.Collections.Generic;  ` `     `  `public` `class` `BalancedParan  ` `{ ` `    ``public` `class` `stack  ` `    ``{ ` `        ``public` `int` `top=-1; ` `        ``public` `char` `[]items = ``new` `char``; ` ` `  `        ``public` `void` `push(``char` `x)  ` `        ``{ ` `            ``if` `(top == 99)  ` `            ``{ ` `                ``Console.WriteLine(``"Stack full"``); ` `            ``}  ` `            ``else` `            ``{ ` `                ``items[++top] = x; ` `            ``} ` `        ``} ` ` `  `        ``char` `pop()  ` `        ``{ ` `            ``if` `(top == -1)  ` `            ``{ ` `                ``Console.WriteLine(``"Underflow error"``); ` `                ``return` `'\0'``; ` `            ``}  ` `            ``else` `            ``{ ` `                ``char` `element = items[top]; ` `                ``top--; ` `                ``return` `element; ` `            ``} ` `        ``} ` ` `  `        ``Boolean isEmpty()  ` `        ``{ ` `            ``return` `(top == -1) ? ``true` `: ``false``; ` `        ``} ` `    ``} ` `     `  `    ``/* Returns true if character1 and character2 ` `    ``are matching left and right Parenthesis */` `    ``static` `Boolean isMatchingPair(``char` `character1, ``char` `character2) ` `    ``{ ` `        ``if` `(character1 == ``'('` `&& character2 == ``')'``) ` `            ``return` `true``; ` `        ``else` `if` `(character1 == ``'{'` `&& character2 == ``'}'``) ` `            ``return` `true``; ` `        ``else` `if` `(character1 == ``'['` `&& character2 == ``']'``) ` `            ``return` `true``; ` `        ``else` `            ``return` `false``; ` `    ``} ` `     `  `    ``/* Return true if expression has balanced  ` `    ``Parenthesis */` `    ``static` `Boolean areParenthesisBalanced(``char` `[]exp) ` `    ``{ ` `        ``/* Declare an empty character stack */` `        ``Stack<``char``> st = ``new` `Stack<``char``>(); ` `         `  `        ``/* Traverse the given expression to  ` `            ``check matching parenthesis */` `        ``for``(``int` `i = 0; i < exp.Length; i++) ` `        ``{ ` `                 `  `            ``/*If the exp[i] is a starting  ` `                ``parenthesis then push it*/` `            ``if` `(exp[i] == ``'{'` `|| exp[i] == ``'('` `|| exp[i] == ``'['``) ` `                ``st.Push(exp[i]); ` `         `  `            ``/* If exp[i] is an ending parenthesis  ` `                ``then pop from stack and check if the  ` `                ``popped parenthesis is a matching pair*/` `            ``if` `(exp[i] == ``'}'` `|| exp[i] == ``')'` `|| exp[i] == ``']'``) ` `            ``{ ` `                     `  `                ``/* If we see an ending parenthesis without  ` `                    ``a pair then return false*/` `                ``if` `(st.Count == 0) ` `                ``{ ` `                    ``return` `false``; ` `                ``}  ` `         `  `                ``/* Pop the top element from stack, if  ` `                    ``it is not a pair parenthesis of character  ` `                    ``then there is a mismatch. This happens for  ` `                    ``expressions like {(}) */` `                ``else` `if` `( !isMatchingPair(st.Pop(), exp[i]) ) ` `                ``{ ` `                    ``return` `false``; ` `                ``} ` `            ``} ` `                 `  `        ``} ` `             `  `        ``/* If there is something left in expression  ` `            ``then there is a starting parenthesis without  ` `            ``a closing parenthesis */` `             `  `        ``if` `(st.Count == 0) ` `            ``return` `true``; ``/*balanced*/` `        ``else` `        ``{ ``/*not balanced*/` `            ``return` `false``; ` `        ``}  ` `    ``}  ` `     `  `    ``/* UTILITY FUNCTIONS */` `    ``/*driver program to test above functions*/` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``char` `[]exp = {``'{'``,``'('``,``')'``,``'}'``,``'['``,``']'``}; ` `        ``if` `(areParenthesisBalanced(exp)) ` `            ``Console.WriteLine(``"Balanced "``); ` `        ``else` `            ``Console.WriteLine(``"Not Balanced "``);  ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```Balanced
```

Time Complexity: O(n)
Auxiliary Space: O(n) for stack.

Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem

My Personal Notes arrow_drop_up

Improved By : 29AjayKumar, AnkitRai01

Article Tags :

41

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.