docs & style: Minor clarification in trie

Author: 4ndrelim

src/main/java/dataStructures/trie/README.md

@@ -19,6 +19,23 @@ This flag is set to true for nodes that correspond to the final character of a c
     <em>Source: <a href="https://java2blog.com/trie-data-structure-in-java/">Java2Blog</a></em>
 </div>
 
+### TrieNode
+A TrieNode represents a single node within a trie, which is a specialized tree-like data structure 
+used primarily for storing strings in a compact format. It typically encapsulates the following:
+
+1. Some kind of data structure to track children nodes; usually a HashMap or an array where indices represent 
+alphabets (e.g. an array of size 26 for chars a-z)
+   - Our implementation uses HashMap which is more versatile since it doesn't restrict the type of characters. But
+   it is not uncommon to see nodes with int or char array. In fact, PS5 of CS2040s does this!
+2. Boolean flag to denote the end of a sequence of characters.
+3. Optional: Additional fields to augment the trie. For instance, one can track the weight of the subtree rooted at each node to
+easily query the number of words with some prefix.
+4. Optional: Parent pointer. Some trie implementations include a back-pointer to the node's parent. This is not required
+for basic trie operations but can be useful for certain algorithms that require traversing the trie in reverse, 
+such as deletions or suffix trie constructions.
+   - Our implementation features one such method where we prune the trie. But we used an array to track past nodes seen
+   rather than rely on parent pointers.
+
 ## Complexity Analysis
 Let the length of the longest word be _L_ and the number of words be _N_.
 

src/main/java/dataStructures/trie/Trie.java

@@ -37,10 +37,11 @@ public TrieNode() {
     public void insert(String word) {
         word = word.toLowerCase(); // ignore case-sensitivity
         TrieNode trav = root;
+        char curr;
         for (int i = 0; i < word.length(); i++) {
-            char curr = word.charAt(i);
+            curr = word.charAt(i);
             if (!trav.children.containsKey(curr)) {
-                trav.children.put(curr, new TrieNode()); // recall, the edges represent the characters
+                trav.children.put(curr, new TrieNode()); // recall: new char is represented by this child node
             }
             trav = trav.children.get(curr);
         }
@@ -55,8 +56,9 @@ public void insert(String word) {
     public boolean search(String word) {
         word = word.toLowerCase();
         TrieNode trav = root;
+        char curr;
         for (int i = 0; i < word.length(); i++) {
-            char curr = word.charAt(i);
+            curr = word.charAt(i);
             if (!trav.children.containsKey(curr)) {
                 return false;
             }
@@ -72,8 +74,9 @@ public boolean search(String word) {
     public void delete(String word) {
         word = word.toLowerCase();
         TrieNode trav = root;
+        char curr;
         for (int i = 0; i < word.length(); i++) {
-            char curr = word.charAt(i);
+            curr = word.charAt(i);
             if (!trav.children.containsKey(curr)) {
                 return; // word does not exist in trie, so just return
             }
@@ -92,8 +95,9 @@ public void delete(String word) {
     public void deleteAndPrune(String word) {
         List<TrieNode> trackNodes = new ArrayList<>();
         TrieNode trav = root;
+        char curr;
         for (int i = 0; i < word.length(); i++) {
-            char curr = word.charAt(i);
+            curr = word.charAt(i);
             if (!trav.children.containsKey(curr)) {
                 return; // word does not exist in trie
             }
@@ -102,12 +106,14 @@ public void deleteAndPrune(String word) {
         }
         trav.isEnd = false;
 
-        // now we start pruning
-        for (int i = word.length() - 1; i >= 0; i--) {
-            char curr = word.charAt(i);
-            TrieNode nodeBeforeCurr = trackNodes.get(i);
-            TrieNode nextNode = nodeBeforeCurr.children.get(curr);
-            if (!nextNode.isEnd && nextNode.children.size() == 0) { // node essentially doesn't track anything, remove
+        // now, we start pruning
+        TrieNode currNode; // nodes representing chars, where chars will be iterated from the back
+        TrieNode nodeBeforeCurr;
+        for (int i = word.length() - 1; i >= 0; i--) { // consider chars from back
+            curr = word.charAt(i);
+            nodeBeforeCurr = trackNodes.get(i);
+            currNode = nodeBeforeCurr.children.get(curr);
+            if (!currNode.isEnd && currNode.children.size() == 0) { // node essentially doesn't track anything, remove
                 nodeBeforeCurr.children.remove(curr);
             } else { // children.size() > 0; i.e. this node is still useful; no need to further prune upwards
                 break;