# 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 < expr.length(); i++) { ` `        ``if` `(expr[i] == ``'('` `|| expr[i] == ``'['` `|| expr[i] == ``'{'``) { ` `            ``// Push the element in the stack ` `            ``s.push(expr[i]); ` `            ``continue``; ` `        ``} ` ` `  `        ``// IF current current character is not opening ` `        ``// bracket, then it must be closing. So stack ` `        ``// cannot be empty at this point. ` `        ``if` `(s.empty()) ` `            ``return` `false``; ` ` `  `        ``switch` `(expr[i]) { ` `        ``case` `')'``: ` ` `  `            ``// Store the top element in a ` `            ``x = s.top(); ` `            ``s.pop(); ` `            ``if` `(x == ``'{'` `|| x == ``'['``) ` `                ``return` `false``; ` `            ``break``; ` ` `  `        ``case` `'}'``: ` ` `  `            ``// Store the top element in b ` `            ``x = s.top(); ` `            ``s.pop(); ` `            ``if` `(x == ``'('` `|| x == ``'['``) ` `                ``return` `false``; ` `            ``break``; ` ` `  `        ``case` `']'``: ` ` `  `            ``// Store the top element in c ` `            ``x = s.top(); ` `            ``s.pop(); ` `            ``if` `(x == ``'('` `|| x == ``'{'``) ` `                ``return` `false``; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Check Empty Stack ` `    ``return` `(s.empty()); ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``string expr = ``"{()}[]"``; ` ` `  `    ``if` `(areParanthesisBalanced(expr)) ` `        ``cout << ``"Balanced"``; ` `    ``else` `        ``cout << ``"Not Balanced"``; ` `    ``return` `0; ` `} `

## 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 ` `import` `java.util.*; ` ` `  `public` `class` `BalancedParan { ` ` `  `    ``// function to check if paranthesis are balanced ` `    ``static` `boolean` `areParanthesisBalanced(String expr) ` `    ``{ ` `        ``// Using ArrayDeque is faster than using Stack class ` `        ``Deque stack = ``new` `ArrayDeque(); ` ` `  `        ``// Traversing the Expression ` `        ``for` `(``int` `i = ``0``; i < expr.length(); i++) { ` `            ``char` `x = expr.charAt(i); ` ` `  `            ``if` `(x == ``'('` `|| x == ``'['` `|| x == ``'{'``) { ` `                ``// Push the element in the stack ` `                ``stack.push(x); ` `                ``continue``; ` `            ``} ` ` `  `            ``// IF current current character is not opening ` `            ``// bracket, then it must be closing. So stack ` `            ``// cannot be empty at this point. ` `            ``if` `(stack.isEmpty()) ` `                ``return` `false``; ` ` `  `            ``switch` `(x) { ` `            ``case` `')'``: ` `                ``stack.pop(); ` `                ``if` `(x == ``'{'` `|| x == ``'['``) ` `                    ``return` `false``; ` `                ``break``; ` ` `  `            ``case` `'}'``: ` `                ``stack.pop(); ` `                ``if` `(x == ``'('` `|| x == ``'['``) ` `                    ``return` `false``; ` `                ``break``; ` ` `  `            ``case` `']'``: ` `                ``stack.pop(); ` `                ``if` `(x == ``'('` `|| x == ``'{'``) ` `                    ``return` `false``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// Check Empty Stack ` `        ``return` `(stack.isEmpty()); ` `    ``} ` ` `  `    ``/*driver program to test above functions*/` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``String expr = ``"([{}])"``; ` `        ``if` `(areParanthesisBalanced(expr)) ` `            ``System.out.println(``"Balanced "``); ` `        ``else` `            ``System.out.println(``"Not Balanced "``); ` `    ``} ` `} `

## Python3

 `# Python3 program to check for ` `# balanced parenthesis.  ` ` `  `# function to check if  ` `# paranthesis are balanced  ` `def` `areParanthesisBalanced(expr) : ` `    ``stack ``=` `[] ` ` `  `    ``# Traversing the Expression  ` `    ``for` `char ``in` `expr: ` `        ``if` `char ``in` `[``"("``, ``"{"``, ``"["``]: ` ` `  `            ``# Push the element in the stack  ` `            ``stack.append(char) ` `        ``else``: ` ` `  `            ``# IF current character is not opening  ` `            ``# bracket, then it must be closing.   ` `            ``# So stack cannot be empty at this point.  ` `            ``if` `not` `stack: ` `                ``return` `False` `            ``current_char ``=` `stack.pop() ` `            ``if` `current_char ``=``=` `'('``: ` `                ``if` `char !``=` `")"``: ` `                    ``return` `False` `            ``if` `current_char ``=``=` `'{'``: ` `                ``if` `char !``=` `"}"``: ` `                    ``return` `False` `            ``if` `current_char ``=``=` `'['``: ` `                ``if` `char !``=` `"]"``: ` `                    ``return` `False` ` `  `    ``# Check Empty Stack ` `    ``if` `stack: ` `        ``return` `False` `    ``return` `True` ` `  ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `:  ` `    ``expr ``=` `"{()}[]"``;  ` `    ``if` `areParanthesisBalanced(expr) : ` `        ``print``(``"Balanced"``);  ` `    ``else` `: ` `        ``print``(``"Not Balanced"``);  ` ` `  `# This code is contributed by AnkitRai01 and improved  ` `# by Raju Pitta `

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :

67

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