Summary: Trie Data Structure

Implement a Trie Data Structure, and search() & insert() function:

we need to implement both Class Trie and Class TrieNode

Class Trie:

 1 import java.util.ArrayList;
 2 import java.util.List;
 3
 4 public class Trie
 5 {
 6    private TrieNode root;
 7
 8    /**
 9     * Constructor
10     */
11    public Trie()
12    {
13       root = new TrieNode();
14    }
15
16    /**
17     * Adds a word to the Trie
18     * @param word
19     */
20    public void addWord(String word)
21    {
22       root.addWord(word.toLowerCase());
23    }
24
25    /**
26     * Get the words in the Trie with the given
27     * prefix
28     * @param prefix
29     * @return a List containing String objects containing the words in
30     *         the Trie with the given prefix.
31     */
32    public List getWords(String prefix)
33    {
34       //Find the node which represents the last letter of the prefix
35       TrieNode lastNode = root;
36       for (int i=0; i<prefix.length(); i++)
37       {
38       lastNode = lastNode.getNode(prefix.charAt(i));
39
40       //If no node matches, then no words exist, return empty list
41       if (lastNode == null) return new ArrayList();
42       }
43
44       //Return the words which eminate from the last node
45       return lastNode.getWords();
46    }
47 }

Class TrieNode:

  1 import java.util.ArrayList;
  2 import java.util.List;
  3
  4 public class TrieNode
  5 {
  6    private TrieNode parent;
  7    private TrieNode[] children;
  8    private boolean isLeaf;     //Quick way to check if any children exist
  9    private boolean isWord;     //Does this node represent the last character of a word
 10    private char character;     //The character this node represents
 11
 12    /**
 13     * Constructor for top level root node.
 14     */
 15    public TrieNode()
 16    {
 17       children = new TrieNode[26];
 18       isLeaf = true;
 19       isWord = false;
 20    }
 21
 22    /**
 23     * Constructor for child node.
 24     */
 25    public TrieNode(char character)
 26    {
 27       this();
 28       this.character = character;
 29    }
 30
 31    /**
 32     * Adds a word to this node. This method is called recursively and
 33     * adds child nodes for each successive letter in the word, therefore
 34     * recursive calls will be made with partial words.
 35     * @param word the word to add
 36     */
 37    protected void addWord(String word)
 38    {
 39       isLeaf = false;
 40       int charPos = word.charAt(0) - ‘a‘;
 41
 42       if (children[charPos] == null)
 43       {
 44       children[charPos] = new TrieNode(word.charAt(0));
 45       children[charPos].parent = this;
 46       }
 47
 48       if (word.length() > 1)
 49       {
 50       children[charPos].addWord(word.substring(1));
 51       }
 52       else
 53       {
 54       children[charPos].isWord = true;
 55       }
 56    }
 57
 58    /**
 59     * Returns the child TrieNode representing the given char,
 60     * or null if no node exists.
 61     * @param c
 62     * @return
 63     */
 64    protected TrieNode getNode(char c)
 65    {
 66       return children[c - ‘a‘];
 67    }
 68
 69    /**
 70     * Returns a List of String objects which are lower in the
 71     * hierarchy that this node.
 72     * @return
 73     */
 74    protected List getWords()
 75    {
 76       //Create a list to return
 77       List list = new ArrayList();
 78
 79       //If this node represents a word, add it
 80       if (isWord)
 81       {
 82       list.add(toString());
 83       }
 84
 85       //If any children
 86       if (!isLeaf)
 87       {
 88       //Add any words belonging to any children
 89       for (int i=0; i<children.length; i++)
 90       {
 91          if (children[i] != null)
 92          {
 93             list.addAll(children.getWords());
 94
 95      }
 96
 97      }
 98
 99 }
100
101 return list;
102
103 }
104
105
106
107 /**
108
109 * Gets the String that this node represents.
110
111 * For example, if this node represents the character t, whose parent
112
113 * represents the charater a, whose parent represents the character
114
115 * c, then the String would be "cat".
116
117 * @return
118
119 */
120
121 public String toString()
122
123 {
124
125 if (parent == null)
126
127 {
128
129      return "";
130
131 }
132
133 else
134
135 {
136
137      return parent.toString() + new String(new char[] {character});
138
139 }
140
141 }
142
143 }