From bd867313b13fd89be96ce0b6f7cd3d7d8fb8e391 Mon Sep 17 00:00:00 2001 From: coder-Basundhara Date: Mon, 13 Oct 2025 10:48:43 +0530 Subject: [PATCH 1/6] Optimized BalancedBrackets implementation with edge cases --- .../stacks/BalancedBrackets.java | 111 ++++++++---------- 1 file changed, 52 insertions(+), 59 deletions(-) diff --git a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java index d3077ff54135..56f9584ffc4a 100644 --- a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java +++ b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java @@ -1,80 +1,73 @@ package com.thealgorithms.stacks; -import java.util.Stack; +import java.util.ArrayDeque; +import java.util.Deque; /** - * 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. + * Optimized and robust Balanced Parenthesis (Valid Brackets) checker. * - * @author akshay sharma - * @author khalil2535 - * @author shellhub + * Supports: (), [], {}, <> + * Rules: + * - Returns true if brackets are properly nested and matched. + * - Returns false for any non-bracket character. + * - Empty string is balanced. + * - Null input throws IllegalArgumentException. + * + * Time complexity: O(n) + * Space complexity: O(n) in worst case (stack contains all opening brackets). */ -final class BalancedBrackets { +public final class BalancedBrackets { + private BalancedBrackets() { + // Utility class } /** - * 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} + * Returns true if {@code opening} and {@code closing} are matching bracket pair. */ - 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; + public static boolean isPaired(char opening, char closing) { + return (opening == '(' && closing == ')') + || (opening == '[' && closing == ']') + || (opening == '{' && closing == '}') + || (opening == '<' && closing == '>'); } /** - * Check if {@code brackets} is balanced + * Checks if the input string has balanced brackets. * - * @param brackets the brackets - * @return {@code true} if {@code brackets} is balanced, otherwise - * {@code false} + * @throws IllegalArgumentException when input is null */ - public static boolean isBalanced(String brackets) { - if (brackets == null) { - throw new IllegalArgumentException("brackets is null"); + public static boolean isBalanced(String input) { + if (input == null) { + throw new IllegalArgumentException("Input cannot be null"); + } + + if (input.isEmpty()) { + return true; } - Stack bracketsStack = new Stack<>(); - for (char bracket : brackets.toCharArray()) { - switch (bracket) { - case '(': - case '[': - case '<': - case '{': - bracketsStack.push(bracket); - break; - case ')': - case ']': - case '>': - case '}': - if (bracketsStack.isEmpty() || !isPaired(bracketsStack.pop(), bracket)) { - return false; + + // Odd-length strings cannot be fully balanced + if ((input.length() & 1) == 1) { + return false; + } + + Deque stack = new ArrayDeque<>(); + + for (char c : input.toCharArray()) { + switch (c) { + case '(', '[', '{', '<' -> stack.push(c); + case ')', ']', '}', '>' -> { + if (stack.isEmpty() || !isPaired(stack.pop(), c)) { + return false; + } + } + default -> { + // Any non-bracket character makes string invalid + return false; } - break; - default: - return false; } } - return bracketsStack.isEmpty(); + + return stack.isEmpty(); } -} +} \ No newline at end of file From 63d93bd7a422083191060d8ad4abfb0809ef62c2 Mon Sep 17 00:00:00 2001 From: coder-Basundhara Date: Mon, 13 Oct 2025 11:03:13 +0530 Subject: [PATCH 2/6] Fix switch statement and improve BalancedBrackets implementation --- .../stacks/BalancedBrackets.java | 55 +++++++++++++++---- 1 file changed, 44 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java index 56f9584ffc4a..c7eb50b60868 100644 --- a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java +++ b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java @@ -55,19 +55,52 @@ public static boolean isBalanced(String input) { for (char c : input.toCharArray()) { switch (c) { - case '(', '[', '{', '<' -> stack.push(c); - case ')', ']', '}', '>' -> { - if (stack.isEmpty() || !isPaired(stack.pop(), c)) { - return false; - } - } - default -> { - // Any non-bracket character makes string invalid - return false; - } + case '(': + case '[': + case '{': + case '<': + stack.push(c); + break; + + case ')': + case ']': + case '}': + case '>': + if (stack.isEmpty() || !isPaired(stack.pop(), c)) { + return false; + } + break; + + default: + // Any non-bracket character makes string invalid + return false; } } return stack.isEmpty(); } -} \ No newline at end of file + + /** + * Optional main method for quick manual testing + */ + public static void main(String[] args) { + String[] tests = { + "()", + "[()]", + "{[<>]}", + "[(])", + "[a+b]", + "", + "<{[()]}>", + "[{<]}>" + }; + + for (String t : tests) { + try { + System.out.println(t + " -> " + isBalanced(t)); + } catch (IllegalArgumentException e) { + System.out.println(t + " -> Error: " + e.getMessage()); + } + } + } +} From 126341714e8a2ad57765b20031fe319c2aabea4e Mon Sep 17 00:00:00 2001 From: coder-Basundhara Date: Mon, 13 Oct 2025 11:08:20 +0530 Subject: [PATCH 3/6] Fix Checkstyle & Clang-Format violations --- src/main/java/com/thealgorithms/stacks/BalancedBrackets.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java index c7eb50b60868..10d47532ff3f 100644 --- a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java +++ b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java @@ -12,7 +12,8 @@ * - Returns false for any non-bracket character. * - Empty string is balanced. * - Null input throws IllegalArgumentException. - * + * @author Basundhara + * @author GitHub * Time complexity: O(n) * Space complexity: O(n) in worst case (stack contains all opening brackets). */ From ff97d47290c23a06e54351580b1c272f14c7dc6a Mon Sep 17 00:00:00 2001 From: coder-Basundhara Date: Mon, 13 Oct 2025 11:13:02 +0530 Subject: [PATCH 4/6] Fix formatting and style for Checkstyle and Clang-Format --- src/main/java/com/thealgorithms/stacks/BalancedBrackets.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java index 10d47532ff3f..4539c79cdfc8 100644 --- a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java +++ b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java @@ -83,7 +83,7 @@ public static boolean isBalanced(String input) { /** * Optional main method for quick manual testing - */ + public static void main(String[] args) { String[] tests = { "()", @@ -104,4 +104,5 @@ public static void main(String[] args) { } } } + **/ } From 3c208dbb1d099faa3e65480e422139a598d3195c Mon Sep 17 00:00:00 2001 From: coder-Basundhara Date: Mon, 13 Oct 2025 11:23:06 +0530 Subject: [PATCH 5/6] Fix: fully Checkstyle-compliant and optimized BalancedBrackets --- .../stacks/BalancedBrackets.java | 29 ++++++++++++------- 1 file changed, 18 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java index 4539c79cdfc8..71899a1006e2 100644 --- a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java +++ b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java @@ -4,18 +4,22 @@ import java.util.Deque; /** - * Optimized and robust Balanced Parenthesis (Valid Brackets) checker. + * BalancedBrackets.java + * Optimized valid parenthesis checker * * Supports: (), [], {}, <> + * * Rules: * - Returns true if brackets are properly nested and matched. * - Returns false for any non-bracket character. * - Empty string is balanced. * - Null input throws IllegalArgumentException. - * @author Basundhara - * @author GitHub + * * Time complexity: O(n) * Space complexity: O(n) in worst case (stack contains all opening brackets). + * + * @author Basundhara + * @author GitHub */ public final class BalancedBrackets { @@ -25,6 +29,10 @@ private BalancedBrackets() { /** * Returns true if {@code opening} and {@code closing} are matching bracket pair. + * + * @param opening opening bracket + * @param closing closing bracket + * @return true if matched */ public static boolean isPaired(char opening, char closing) { return (opening == '(' && closing == ')') @@ -36,6 +44,8 @@ public static boolean isPaired(char opening, char closing) { /** * Checks if the input string has balanced brackets. * + * @param input input string + * @return true if balanced * @throws IllegalArgumentException when input is null */ public static boolean isBalanced(String input) { @@ -47,7 +57,7 @@ public static boolean isBalanced(String input) { return true; } - // Odd-length strings cannot be fully balanced + // Odd-length strings cannot be balanced if ((input.length() & 1) == 1) { return false; } @@ -62,7 +72,6 @@ public static boolean isBalanced(String input) { case '<': stack.push(c); break; - case ')': case ']': case '}': @@ -71,7 +80,6 @@ public static boolean isBalanced(String input) { return false; } break; - default: // Any non-bracket character makes string invalid return false; @@ -83,7 +91,7 @@ public static boolean isBalanced(String input) { /** * Optional main method for quick manual testing - + */ public static void main(String[] args) { String[] tests = { "()", @@ -98,11 +106,10 @@ public static void main(String[] args) { for (String t : tests) { try { - System.out.println(t + " -> " + isBalanced(t)); - } catch (IllegalArgumentException e) { - System.out.println(t + " -> Error: " + e.getMessage()); + System.out.printf("%s -> %b%n", t, isBalanced(t)); + } catch (Exception e) { + System.out.printf("%s -> Exception: %s%n", t, e.getMessage()); } } } - **/ } From a87d5d096da7b8479d8a1e6155ad46f103569fd0 Mon Sep 17 00:00:00 2001 From: coder-Basundhara Date: Mon, 13 Oct 2025 11:30:42 +0530 Subject: [PATCH 6/6] Fix: fully Checkstyle-compliant and optimized BalancedBrackets --- .../stacks/BalancedBrackets.java | 24 +------------------ 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java index 71899a1006e2..261a2330cac8 100644 --- a/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java +++ b/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java @@ -89,27 +89,5 @@ public static boolean isBalanced(String input) { return stack.isEmpty(); } - /** - * Optional main method for quick manual testing - */ - public static void main(String[] args) { - String[] tests = { - "()", - "[()]", - "{[<>]}", - "[(])", - "[a+b]", - "", - "<{[()]}>", - "[{<]}>" - }; - - for (String t : tests) { - try { - System.out.printf("%s -> %b%n", t, isBalanced(t)); - } catch (Exception e) { - System.out.printf("%s -> Exception: %s%n", t, e.getMessage()); - } - } - } + }