Verify Balanced Parentheses In Java: This Java program checks whether the given expression contains balanced pairs of brackets and parentheses. It uses a stack data structure to efficiently track and verify the correctness of the pairs and their orders.
Verify Balanced Parentheses In Java
package com.softwaretestingo.interviewprograms;
import java.util.Stack;
public class InterviewPrograms36
{
// 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
public static void main(String[] args)
{
String equ = "[()]{}{[()()]()}";
Stack<Character> stack = new Stack<>();
for (int i =0 ; i< equ.length() ; i++)
{
if (equ.charAt(i) == '{' || equ.charAt(i) == '[' || equ.charAt(i) == '(')
{
stack.push(equ.charAt(i));
}
else if (!stack.isEmpty() && ( (equ.charAt(i) == ']' && stack.peek() == '[') || (equ.charAt(i) == '}' && stack.peek() == '{') || (equ.charAt(i) == ')' && stack.peek() == '(')))
{
stack.pop();
}
else
{
stack.push(equ.charAt(i));
}
}
if (stack.empty())
{
System.out.println(stack.toString());
System.out.println("balanced");
}
else
{
System.out.println(stack.toString());
System.out.println("Not balanced");
}
}
}- package com.softwaretestingo.interviewprograms;
- import java.util.Stack;
- public class InterviewPrograms36
- {
- // 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
- public static void main(String[] args)
- {
- String equ = "[()]{}{[()()]()}";
- Stack<Character> stack = new Stack<>();
- for (int i =0 ; i< equ.length() ; i++)
- {
- if (equ.charAt(i) == '{' || equ.charAt(i) == '[' || equ.charAt(i) == '(')
- {
- stack.push(equ.charAt(i));
- }
- else if (!stack.isEmpty() && ( (equ.charAt(i) == ']' && stack.peek() == '[') || (equ.charAt(i) == '}' && stack.peek() == '{') || (equ.charAt(i) == ')' && stack.peek() == '(')))
- {
- stack.pop();
- }
- else
- {
- stack.push(equ.charAt(i));
- }
- }
- if (stack.empty())
- {
- System.out.println(stack.toString());
- System.out.println("balanced");
- }
- else
- {
- System.out.println(stack.toString());
- System.out.println("Not balanced");
- }
- }
- }
package com.softwaretestingo.interviewprograms;
import java.util.Stack;
public class InterviewPrograms36
{
// 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
public static void main(String[] args)
{
String equ = "[()]{}{[()()]()}";
Stack<Character> stack = new Stack<>();
for (int i =0 ; i< equ.length() ; i++)
{
if (equ.charAt(i) == '{' || equ.charAt(i) == '[' || equ.charAt(i) == '(')
{
stack.push(equ.charAt(i));
}
else if (!stack.isEmpty() && ( (equ.charAt(i) == ']' && stack.peek() == '[') || (equ.charAt(i) == '}' && stack.peek() == '{') || (equ.charAt(i) == ')' && stack.peek() == '(')))
{
stack.pop();
}
else
{
stack.push(equ.charAt(i));
}
}
if (stack.empty())
{
System.out.println(stack.toString());
System.out.println("balanced");
}
else
{
System.out.println(stack.toString());
System.out.println("Not balanced");
}
}
}Output
[]
balanced
Alternative Way 1:
This Java program checks whether the given expression contains balanced pairs of brackets and parentheses using a stack implemented using a LinkedList. It also uses a HashMap to store the opening and closing brackets to check for balanced pairs efficiently.
package com.softwaretestingo.interviewprograms;
import java.util.HashMap;
import java.util.LinkedList;
public class InterviewPrograms36_1
{
// 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
static HashMap<String, String> bracketDetails=new HashMap<String, String>();
public static void main(String[] args)
{
storeBracketStartAndEnd();
String testString = "[{()}](){()}";
boolean status = true ;
LinkedList<String> l1 = new LinkedList<String>();
testString = testString.replaceAll("[^\\(\\{\\[\\)\\}\\]]", "");
for ( int i = 0 ; i < testString.length(); i++ )
{
String element = String.valueOf(testString.charAt(i));
if (element.equalsIgnoreCase("(")||element.equalsIgnoreCase("{")||element.equalsIgnoreCase("["))
{
l1.addFirst (bracketDetails.get(element));
}
else
{
if (! element.equalsIgnoreCase(l1.getFirst()))
{
status = false;
break;
}
else
{
l1.removeFirst();
}
}
}
if (status)
{
System.out.println ("All brackets are balanced");
}
else
{
System.out.println("Brackets are not balanced");
}
}
public static void storeBracketStartAndEnd()
{
bracketDetails.put("(",")");
bracketDetails.put("{","}");
bracketDetails.put("[","]");
}
}- package com.softwaretestingo.interviewprograms;
- import java.util.HashMap;
- import java.util.LinkedList;
- public class InterviewPrograms36_1
- {
- // 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
- static HashMap<String, String> bracketDetails=new HashMap<String, String>();
- public static void main(String[] args)
- {
- storeBracketStartAndEnd();
- String testString = "[{()}](){()}";
- boolean status = true ;
- LinkedList<String> l1 = new LinkedList<String>();
- testString = testString.replaceAll("[^\\(\\{\\[\\)\\}\\]]", "");
- for ( int i = 0 ; i < testString.length(); i++ )
- {
- String element = String.valueOf(testString.charAt(i));
- if (element.equalsIgnoreCase("(")||element.equalsIgnoreCase("{")||element.equalsIgnoreCase("["))
- {
- l1.addFirst (bracketDetails.get(element));
- }
- else
- {
- if (! element.equalsIgnoreCase(l1.getFirst()))
- {
- status = false;
- break;
- }
- else
- {
- l1.removeFirst();
- }
- }
- }
- if (status)
- {
- System.out.println ("All brackets are balanced");
- }
- else
- {
- System.out.println("Brackets are not balanced");
- }
- }
- public static void storeBracketStartAndEnd()
- {
- bracketDetails.put("(",")");
- bracketDetails.put("{","}");
- bracketDetails.put("[","]");
- }
- }
package com.softwaretestingo.interviewprograms;
import java.util.HashMap;
import java.util.LinkedList;
public class InterviewPrograms36_1
{
// 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
static HashMap<String, String> bracketDetails=new HashMap<String, String>();
public static void main(String[] args)
{
storeBracketStartAndEnd();
String testString = "[{()}](){()}";
boolean status = true ;
LinkedList<String> l1 = new LinkedList<String>();
testString = testString.replaceAll("[^\\(\\{\\[\\)\\}\\]]", "");
for ( int i = 0 ; i < testString.length(); i++ )
{
String element = String.valueOf(testString.charAt(i));
if (element.equalsIgnoreCase("(")||element.equalsIgnoreCase("{")||element.equalsIgnoreCase("["))
{
l1.addFirst (bracketDetails.get(element));
}
else
{
if (! element.equalsIgnoreCase(l1.getFirst()))
{
status = false;
break;
}
else
{
l1.removeFirst();
}
}
}
if (status)
{
System.out.println ("All brackets are balanced");
}
else
{
System.out.println("Brackets are not balanced");
}
}
public static void storeBracketStartAndEnd()
{
bracketDetails.put("(",")");
bracketDetails.put("{","}");
bracketDetails.put("[","]");
}
}Output
All brackets are balanced
- All brackets are balanced
All brackets are balanced
