Refactor PatriciaTrie for improved readability

Author: shimmer12

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

@@ -1,42 +1,38 @@
 package com.thealgorithms.datastructures.tries;
 
-// FIX: Placed each import on its own line for proper formatting.
 import java.util.HashMap;
 import java.util.Map;
 
 /**
  * Patricia (radix) trie for String keys and generic values.
  *
- * <p>A Patricia Trie is a memory-optimized trie where each node with only one
- * child is merged with its child. This results in edges being labeled with
- * strings instead of single characters.</p>
+ * <p>A Patricia Trie is a memory-optimized trie where nodes with a single child
+ * are merged, so edges are labeled with strings instead of single characters.</p>
  *
  * <p>Operations are O(L) where L is the key length.</p>
  *
  * <p>Contracts:
  * <ul>
- * <li>Null keys are not allowed (IllegalArgumentException).</li>
- * <li>The empty-string key ("") is a valid key.</li>
- * <li>Null values are not allowed (IllegalArgumentException).</li>
+ *   <li>Null keys are not allowed (IllegalArgumentException).</li>
+ *   <li>The empty-string key ("") is a valid key.</li>
+ *   <li>Null values are not allowed (IllegalArgumentException).</li>
  * </ul>
  * </p>
  */
-// FIX: Added a newline after the Javadoc for proper formatting.
 public final class PatriciaTrie<V> {
 
     /** Node with compressed outgoing edges (label -> child). */
     private static final class Node<V> {
-        Map<String, Node<V>> children = new HashMap<>();
-        boolean hasValue;
-        V value;
+        private final Map<String, Node<V>> children = new HashMap<>();
+        private boolean hasValue;
+        private V value;
     }
 
     private final Node<V> root = new Node<>();
     private int size; // number of stored keys
 
     /** Creates an empty Patricia trie. */
-    public PatriciaTrie() {
-    }
+    public PatriciaTrie() {}
 
     /**
      * Inserts or updates the value associated with {@code key}.
@@ -95,7 +91,6 @@ public boolean remove(String key) {
         if (key == null) {
             throw new IllegalArgumentException("key must not be null");
         }
-        // The empty key is a special case as it's stored on the root node.
         if (key.isEmpty()) {
             if (root.hasValue) {
                 root.hasValue = false;
@@ -154,11 +149,10 @@ private void insert(Node<V> node, String key, V value) {
             int cpl = commonPrefixLen(edge, key);
 
             if (cpl == 0) {
-                continue; // No common prefix, check next child.
+                continue; // No common prefix, try next edge.
             }
 
-            // Case 1: The entire edge and key match perfectly.
-            // e.g., edge="apple", key="apple". Update the value at the child node.
+            // Case 1: edge == key
             if (cpl == edge.length() && cpl == key.length()) {
                 Node<V> child = e.getValue();
                 if (!child.hasValue) {
@@ -169,17 +163,15 @@ private void insert(Node<V> node, String key, V value) {
                 return;
             }
 
-            // Case 2: The edge is a prefix of the key.
-            // e.g., edge="apple", key="applepie". Recurse on the child node.
+            // Case 2: edge is prefix of key
             if (cpl == edge.length() && cpl < key.length()) {
                 Node<V> child = e.getValue();
                 String rest = key.substring(cpl);
                 insert(child, rest, value);
                 return;
             }
 
-            // Case 3: The key and edge partially match, requiring a split.
-            // e.g., edge="romane", key="romanus" -> split at "roman".
+            // Case 3: partial overlap → split
             String prefix = edge.substring(0, cpl);
             String edgeSuffix = edge.substring(cpl);
             String keySuffix = key.substring(cpl);
@@ -188,30 +180,29 @@ private void insert(Node<V> node, String key, V value) {
             node.children.remove(edge);
             node.children.put(prefix, mid);
 
-            // The old child is re-attached to the new middle node.
+            // Reattach old child under the split node
             Node<V> oldChild = e.getValue();
             mid.children.put(edgeSuffix, oldChild);
 
             if (keySuffix.isEmpty()) {
-                // The new key ends at the split point, e.g., inserting "roman"
+                // New key ends at split
                 if (!mid.hasValue) {
                     size++;
                 }
                 mid.hasValue = true;
                 mid.value = value;
             } else {
-                // The new key branches off after the split point, e.g., "romanus"
+                // New branch after split
                 Node<V> leaf = new Node<>();
                 leaf.hasValue = true;
                 leaf.value = value;
                 mid.children.put(keySuffix, leaf);
-                // FIX: This was the main bug. A new key was added, but size was not incremented.
-                size++;
+                size++; // important: new key added
             }
             return;
         }
 
-        // Case 4: No existing edge shares a prefix. Create a new one.
+        // Case 4: no shared prefix; create a new edge
         Node<V> leaf = new Node<>();
         leaf.hasValue = true;
         leaf.value = value;
@@ -250,11 +241,9 @@ private Node<V> findPrefixNode(Node<V> node, String prefix) {
         return null;
     }
 
-    /**
-     * Recursive removal with cleanup (merging pass-through nodes).
-     */
+    /** Recursive removal with cleanup (merging pass-through nodes). */
     private boolean removeRecursive(Node<V> parent, String key) {
-        // Iterate on a snapshot to allow modification during the loop.
+        // Iterate on a snapshot to allow modification during the loop
         for (Map.Entry<String, Node<V>> entry : new HashMap<>(parent.children).entrySet()) {
             String edge = entry.getKey();
             Node<V> child = entry.getValue();
@@ -266,40 +255,35 @@ private boolean removeRecursive(Node<V> parent, String key) {
             String rest = key.substring(edge.length());
             boolean removed;
             if (rest.isEmpty()) {
-                // This is the node to delete.
                 if (!child.hasValue) {
-                    return false; // Key doesn't actually exist.
+                    return false; // key not present
                 }
                 child.hasValue = false;
                 child.value = null;
                 size--;
                 removed = true;
             } else {
-                // Continue search down the tree.
                 removed = removeRecursive(child, rest);
             }
 
             if (!removed) {
                 return false;
             }
 
-            // Post-recursion cleanup: merge nodes if necessary.
+            // Cleanup/compaction
             if (!child.hasValue) {
-                int childDegree = child.children.size();
-                if (childDegree == 0) {
-                    // If child is now a valueless leaf, remove it.
+                int degree = child.children.size();
+                if (degree == 0) {
                     parent.children.remove(edge);
-                } else if (childDegree == 1) {
-                    // If child is a pass-through node, merge it with its own child.
-                    Map.Entry<String, Node<V>> grandchildEntry = child.children.entrySet().iterator().next();
-                    String grandEdge = grandchildEntry.getKey();
-                    Node<V> grandchild = grandchildEntry.getValue();
-
+                } else if (degree == 1) {
+                    Map.Entry<String, Node<V>> gc = child.children.entrySet().iterator().next();
+                    String grandEdge = gc.getKey();
+                    Node<V> grandchild = gc.getValue();
                     parent.children.remove(edge);
                     parent.children.put(edge + grandEdge, grandchild);
                 }
             }
-            return true; // Key was found and processed in this path.
+            return true; // processed on this path
         }
         return false;
     }