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:

 import java.util.ArrayList;
 import java.util.List;

 public class Trie
 {
    private TrieNode root;

    /**
     * Constructor
     */
    public Trie()
    {
       root = new TrieNode();
    }

    /**
     * Adds a word to the Trie
     * @param word
     */
    public void addWord(String word)
    {
       root.addWord(word.toLowerCase());
    }

    /**
     * Get the words in the Trie with the given
     * prefix
     * @param prefix
     * @return a List containing String objects containing the words in
     *         the Trie with the given prefix.
     */
    public List getWords(String prefix)
    {
       //Find the node which represents the last letter of the prefix
       TrieNode lastNode = root;
       for (int i=0; i<prefix.length(); i++)
       {
       lastNode = lastNode.getNode(prefix.charAt(i));

       //If no node matches, then no words exist, return empty list
       if (lastNode == null) return new ArrayList();
       }

       //Return the words which eminate from the last node
       return lastNode.getWords();
    }
 }

Class TrieNode:

 import java.util.ArrayList;
 import java.util.List;

 public class TrieNode
 {
    private TrieNode parent;
    private TrieNode[] children;
    private boolean isLeaf;     //Quick way to check if any children exist
    private boolean isWord;     //Does this node represent the last character of a word
    private char character;     //The character this node represents

    /**
     * Constructor for top level root node.
     */
    public TrieNode()
    {
       children = new TrieNode[26];
       isLeaf = true;
       isWord = false;
    }

    /**
     * Constructor for child node.
     */
    public TrieNode(char character)
    {
       this();
       this.character = character;
    }

    /**
     * Adds a word to this node. This method is called recursively and
     * adds child nodes for each successive letter in the word, therefore
     * recursive calls will be made with partial words.
     * @param word the word to add
     */
    protected void addWord(String word)
    {
       isLeaf = false;
       int charPos = word.charAt(0) - 'a';

       if (children[charPos] == null)
       {
       children[charPos] = new TrieNode(word.charAt(0));
       children[charPos].parent = this;
       }

       if (word.length() > 1)
       {
       children[charPos].addWord(word.substring(1));
       }
       else
       {
       children[charPos].isWord = true;
       }
    }

    /**
     * Returns the child TrieNode representing the given char,
     * or null if no node exists.
     * @param c
     * @return
     */
    protected TrieNode getNode(char c)
    {
       return children[c - 'a'];
    }

    /**
     * Returns a List of String objects which are lower in the
     * hierarchy that this node.
     * @return
     */
    protected List getWords()
    {
       //Create a list to return
       List list = new ArrayList();

       //If this node represents a word, add it
       if (isWord)
       {
       list.add(toString());
       }

       //If any children
       if (!isLeaf)
       {
       //Add any words belonging to any children
       for (int i=0; i<children.length; i++)
       {
          if (children[i] != null)
          {
             list.addAll(children.getWords());

      }

      }

 }

 return list; 

 }

 /**

 * Gets the String that this node represents.

 * For example, if this node represents the character t, whose parent

 * represents the charater a, whose parent represents the character

 * c, then the String would be "cat".

 * @return

 */

 public String toString()

 {

 if (parent == null)

 {

      return "";

 }

 else

 {

      return parent.toString() + new String(new char[] {character});

 }

 } 

 }