fix: update ValidParentheses with Deque and improved tests

Author: Ruturaj-007

src/main/java/com/thealgorithms/stacks/ValidParentheses.java

@@ -1,38 +1,39 @@
 package com.thealgorithms.stacks;
 
-import java.util.Stack;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Map;
 
 /**
- * Utility class to check for valid parentheses in a string.
+ * Utility class to check if a string has valid parentheses.
  */
 public final class ValidParentheses {
 
     private ValidParentheses() {
         throw new AssertionError("Cannot instantiate utility class");
     }
 
+    private static final Map<Character, Character> PAIRS = Map.of(
+            ')', '(', '}', '{', ']', '['
+    );
+
     /**
-     * Returns true if the input string has valid parentheses.
+     * Checks if the input string has valid parentheses.
      *
-     * @param s the string containing parentheses
+     * @param s the input string
      * @return true if valid, false otherwise
      */
     public static boolean isValid(final String s) {
-        final Stack<Character> stack = new Stack<>();
+        if (s == null) {
+            throw new NullPointerException("Input cannot be null");
+        }
 
-        for (final char ch : s.toCharArray()) {
-            if (ch == '(' || ch == '{' || ch == '[') {
+        Deque<Character> stack = new ArrayDeque<>();
+        for (char ch : s.toCharArray()) {
+            if (PAIRS.containsValue(ch)) { // opening bracket
                 stack.push(ch);
-            } else if (ch == ')' || ch == '}' || ch == ']') {
-                if (stack.isEmpty()) {
-                    return false;
-                }
-                final char top = stack.peek();
-                if ((top == '(' && ch == ')')
-                        || (top == '{' && ch == '}')
-                        || (top == '[' && ch == ']')) {
-                    stack.pop();
-                } else {
+            } else if (PAIRS.containsKey(ch)) { // closing bracket
+                if (stack.isEmpty() || stack.pop() != PAIRS.get(ch)) {
                     return false;
                 }
             }

src/test/java/com/thealgorithms/stacks/ValidParenthesesTest.java

@@ -1,45 +1,44 @@
 package com.thealgorithms.stacks;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import java.util.stream.Stream;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.CsvSource;
 
 /**
  * Tests for {@link ValidParentheses}.
  */
 public class ValidParenthesesTest {
 
     @ParameterizedTest
-    @MethodSource("provideValidTestCases")
-    void testIsValidValidCases(String input, Boolean expected) {
+    @CsvSource({
+            "'()', true",
+            "'()[]{}', true",
+            "'{[]}', true",
+            "'', true"
+    })
+    void testValidParentheses(String input, boolean expected) {
         assertEquals(expected, ValidParentheses.isValid(input));
     }
 
-    static Stream<Arguments> provideValidTestCases() {
-        return Stream.of(
-                Arguments.of("()", Boolean.TRUE),
-                Arguments.of("()[]{}", Boolean.TRUE),
-                Arguments.of("{[]}", Boolean.TRUE),
-                Arguments.of("", Boolean.TRUE) // empty string is valid
-        );
-    }
-
     @ParameterizedTest
-    @MethodSource("provideInvalidTestCases")
-    void testIsValidInvalidCases(String input, Boolean expected) {
+    @CsvSource({
+            "'(', false",
+            "')', false",
+            "'([)]', false",
+            "'{[}]', false",
+            "'((()', false"
+    })
+    void testInvalidParentheses(String input, boolean expected) {
         assertEquals(expected, ValidParentheses.isValid(input));
     }
 
-    static Stream<Arguments> provideInvalidTestCases() {
-        return Stream.of(
-                Arguments.of("(", Boolean.FALSE),
-                Arguments.of(")", Boolean.FALSE),
-                Arguments.of("([)]", Boolean.FALSE),
-                Arguments.of("{[}]", Boolean.FALSE),
-                Arguments.of("((()", Boolean.FALSE)
-        );
+    @ParameterizedTest
+    @CsvSource({
+            "null"
+    })
+    void testNullInput(String input) {
+        assertThrows(NullPointerException.class, () -> ValidParentheses.isValid(null));
     }
 }