feat: add Valid Parentheses algorithm using Stack (#7117)

* feat: add Valid Parentheses algorithm using Stack

* fix: add missing ValidParentheses.java implementation

* fix: remove trailing spaces and add newline at EOF

* fix: remove misplaced ValidParentheses.java from root

Author: Gokul45-45

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

@@ -0,0 +1,74 @@
+package com.thealgorithms.stacks;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+/**
+ * Valid Parentheses Problem
+ *
+ * Given a string containing just the characters '(', ')', '{', '}', '[' and ']',
+ * determine if the input string is valid.
+ *
+ * An input string is valid if:
+ * 1. Open brackets must be closed by the same type of brackets.
+ * 2. Open brackets must be closed in the correct order.
+ * 3. Every close bracket has a corresponding open bracket of the same type.
+ *
+ * Examples:
+ * Input: "()"
+ * Output: true
+ *
+ * Input: "()[]{}"
+ * Output: true
+ *
+ * Input: "(]"
+ * Output: false
+ *
+ * Input: "([)]"
+ * Output: false
+ *
+ * @author Gokul45-45
+ */
+public final class ValidParentheses {
+    private ValidParentheses() {
+    }
+
+    /**
+     * Checks if the given string has valid parentheses
+     *
+     * @param s the input string containing parentheses
+     * @return true if valid, false otherwise
+     */
+    public static boolean isValid(String s) {
+        if (s == null || s.length() % 2 != 0) {
+            return false;
+        }
+
+        Map<Character, Character> parenthesesMap = new HashMap<>();
+        parenthesesMap.put('(', ')');
+        parenthesesMap.put('{', '}');
+        parenthesesMap.put('[', ']');
+
+        Stack<Character> stack = new Stack<>();
+
+        for (char c : s.toCharArray()) {
+            if (parenthesesMap.containsKey(c)) {
+                // Opening bracket - push to stack
+                stack.push(c);
+            } else {
+                // Closing bracket - check if it matches
+                if (stack.isEmpty()) {
+                    return false;
+                }
+                char openBracket = stack.pop();
+                if (parenthesesMap.get(openBracket) != c) {
+                    return false;
+                }
+            }
+        }
+
+        // Stack should be empty if all brackets are matched
+        return stack.isEmpty();
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.thealgorithms.stacks;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class ValidParenthesesTest {
+
+    @Test
+    void testValidParentheses() {
+        assertTrue(ValidParentheses.isValid("()"));
+        assertTrue(ValidParentheses.isValid("()[]{}"));
+        assertTrue(ValidParentheses.isValid("{[]}"));
+        assertTrue(ValidParentheses.isValid(""));
+    }
+
+    @Test
+    void testInvalidParentheses() {
+        assertFalse(ValidParentheses.isValid("(]"));
+        assertFalse(ValidParentheses.isValid("([)]"));
+        assertFalse(ValidParentheses.isValid("{{{"));
+        assertFalse(ValidParentheses.isValid("}"));
+        assertFalse(ValidParentheses.isValid("("));
+    }
+
+    @Test
+    void testNullAndOddLength() {
+        assertFalse(ValidParentheses.isValid(null));
+        assertFalse(ValidParentheses.isValid("(()"));
+    }
+}