Added Tries

Author: Jeevan-23

src/main/java/com/thealgorithms/datastructures/tries/Trie.java

@@ -0,0 +1,125 @@
+package com.thealgorithms.datastructures.tries;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A Trie (prefix tree) data structure implementation for storing strings.
+ *
+ * <p>
+ * The Trie allows for efficient insertion, search, and prefix-matching
+ * operations.
+ * It is commonly used for tasks such as autocomplete, spell checking, and
+ * dictionary storage.
+ *
+ * <p>
+ * This implementation supports only lowercase English letters by default but
+ * can
+ * be easily extended to handle other character sets using a {@link HashMap}.
+ *
+ * <p>
+ * Trie is not thread-safe and should not be accessed by multiple threads
+ * concurrently.
+ */
+public class Trie {
+
+    /** The root node of the Trie. */
+    private final TrieNode root;
+
+    /**
+     * Constructs an empty Trie.
+     * <p>
+     * This initializes the Trie with an empty root node.
+     */
+    public Trie() {
+        root = new TrieNode();
+    }
+
+    /**
+     * Inserts a word into the Trie.
+     *
+     * <p>
+     * This method adds all characters of the specified word into the Trie.
+     * If a character path does not exist, it is created. At the end of the word,
+     * the terminal node is marked as an end of a valid word.
+     *
+     * @param word the word to insert; must not be {@code null} or empty
+     */
+    public void insert(String word) {
+        TrieNode currentNode = root;
+        for (char ch : word.toCharArray()) {
+            currentNode.children.putIfAbsent(ch, new TrieNode());
+            currentNode = currentNode.children.get(ch);
+        }
+        currentNode.isEndOfWord = true;
+    }
+
+    /**
+     * Checks whether the Trie contains a specific word.
+     *
+     * <p>
+     * This method returns {@code true} only if the exact word has been inserted
+     * into the Trie earlier.
+     *
+     * @param word the word to check for; must not be {@code null}
+     * @return {@code true} if the Trie contains the specified word; {@code false}
+     *         otherwise
+     */
+    public boolean search(String word) {
+        TrieNode currentNode = root;
+        for (char ch : word.toCharArray()) {
+            currentNode = currentNode.children.get(ch);
+            if (currentNode == null) {
+                return false;
+            }
+        }
+        return currentNode.isEndOfWord;
+    }
+
+    /**
+     * Checks whether there is any word in the Trie that starts with the given
+     * prefix.
+     *
+     * <p>
+     * This method is useful for prefix-based searches or autocomplete
+     * functionality.
+     *
+     * @param prefix the prefix to check for; must not be {@code null}
+     * @return {@code true} if there is at least one word starting with the prefix;
+     *         {@code false} otherwise
+     */
+    public boolean startsWith(String prefix) {
+        TrieNode currentNode = root;
+        for (char ch : prefix.toCharArray()) {
+            currentNode = currentNode.children.get(ch);
+            if (currentNode == null) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Represents a single node in the Trie.
+     *
+     * <p>
+     * Each node maintains a mapping of character children and a flag indicating
+     * whether it represents the end of a valid word.
+     */
+    private static class TrieNode {
+        private final Map<Character, TrieNode> children;
+        private boolean isEndOfWord;
+
+        /**
+         * Constructs an empty TrieNode.
+         *
+         * <p>
+         * Initializes an empty map for child nodes and sets the end-of-word flag to
+         * false.
+         */
+        TrieNode() {
+            children = new HashMap<>();
+            isEndOfWord = false;
+        }
+    }
+}