Balanced Brackets Algorithm
The Balanced Brackets Algorithm is a popular programming challenge that requires determining whether a given string containing various types of brackets is properly balanced or not. The problem typically involves three types of brackets: parentheses (()), square brackets ([]), and curly brackets ({}). A string is considered to be balanced if each opening bracket has a corresponding closing bracket and the brackets are properly nested. For example, the strings "{[()]}" and "{[()()]}" are balanced, while the strings "{[(])}" and "{[}" are not.
To solve the Balanced Brackets Algorithm, one can make use of a stack data structure. The algorithm iterates through each character in the given string. If the character is an opening bracket, it is pushed onto the stack. If the character is a closing bracket, the top element is popped from the stack and checked whether it corresponds to the correct opening bracket. If not, the string is considered unbalanced. If the stack is empty after iterating through the entire string, the string is balanced; otherwise, it's unbalanced. This approach ensures that the algorithm processes the input string in linear time, with a time complexity of O(n), where n is the length of the input string.
package DataStructures.Stacks;
import java.util.Stack;
/**
* The nested brackets problem is a problem that determines if a sequence of
* brackets are properly nested. A sequence of brackets s is considered properly
* nested if any of the following conditions are true: - s is empty - s has the
* form (U) or [U] or {U} where U is a properly nested string - s has the form
* VW where V and W are properly nested strings For example, the string
* "()()[()]" is properly nested but "[(()]" is not. The function called
* is_balanced takes as input a string S which is a sequence of brackets and
* returns true if S is nested and false otherwise.
*
* @author akshay sharma
* @author <a href="https://github.com/khalil2535">khalil2535<a>
* @author shellhub
*/
class BalancedBrackets {
/**
* Check if {@code leftBracket} and {@code rightBracket} is paired or not
*
* @param leftBracket left bracket
* @param rightBracket right bracket
* @return {@code true} if {@code leftBracket} and {@code rightBracket} is paired,
* otherwise {@code false}
*/
public static boolean isPaired(char leftBracket, char rightBracket) {
char[][] pairedBrackets = {
{'(', ')'},
{'[', ']'},
{'{', '}'},
{'<', '>'}
};
for (char[] pairedBracket : pairedBrackets) {
if (pairedBracket[0] == leftBracket && pairedBracket[1] == rightBracket) {
return true;
}
}
return false;
}
/**
* Check if {@code brackets} is balanced
*
* @param brackets the brackets
* @return {@code true} if {@code brackets} is balanced, otherwise {@code false}
*/
public static boolean isBalanced(String brackets) {
if (brackets == null) {
throw new IllegalArgumentException("brackets is null");
}
Stack<Character> bracketsStack = new Stack<>();
for (char bracket : brackets.toCharArray()) {
switch (bracket) {
case '(':
case '[':
case '{':
bracketsStack.push(bracket);
break;
case ')':
case ']':
case '}':
if (bracketsStack.isEmpty() || !isPaired(bracketsStack.pop(), bracket)) {
return false;
}
break;
default: /* other character is invalid */
return false;
}
}
return bracketsStack.isEmpty();
}
public static void main(String[] args) {
assert isBalanced("[()]{}{[()()]()}");
assert !isBalanced("[(])");
}
}
