Implement Trie and find longest prefix string list

　　

 package leetcode;

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

 class TrieNode{
     Boolean isWord;//true if path till this node represent a string.
     Integer freq;//numbers of strings share the same prefix
     Character nodeChar;//character for this node
     ArrayList<TrieNode> childNodes;
     public TrieNode(char c){
         childNodes = new ArrayList<TrieNode>();
         this.nodeChar = c;
         this.freq = 1;
         this.isWord = false;
     }
     public TrieNode(){
         childNodes = new ArrayList<TrieNode>();
         this.nodeChar = null;
         this.freq = 0;
         this.isWord = false;
     }
 }

 class Prefix{
     TrieNode root;
     String prefix;
     public Prefix(TrieNode root, String s){
         this.root = root;
         this.prefix = s;
     }
 }

 public class Trie {
     /*
     Trie is an efficient information retrieval data structure.
     Using trie, search complexities can be brought to optimal limit (key length).
     If we store keys in binary search tree, a well balanced BST will need time proportional to M * log N,
     where M is maximum string length and N is number of keys in tree.
     Using trie, we can search the key in O(M) time.
     However the penalty is on trie storage requirements.
     */
     TrieNode root;
     public Trie(){
         root = new TrieNode();
     }

     public void insert(String s){
         if(s == null || s.length() == 0) return;
         TrieNode tmp = root;
         tmp.freq ++;// prefix freq ++
         for(int i = 0; i < s.length(); i ++){
             Boolean hasNode = false;
             for(int j = 0; j < tmp.childNodes.size(); j ++){
                 if(tmp.childNodes.get(j).nodeChar == s.charAt(i)){
                     tmp = tmp.childNodes.get(j);
                     tmp.freq ++;
                     hasNode = true;
                     break;
                 }
             }
             if(hasNode == false){
                 TrieNode newNode = new TrieNode(s.charAt(i));
                 tmp.childNodes.add(newNode);
                 tmp = newNode;
             }
         }
         tmp.isWord = true;
     }

     public Boolean searchString(String s){
         if(s == null || s.length() == 0) return false;
         TrieNode tmp = root;
         for(int i = 0; i < s.length(); i ++){
             Boolean containsChar = false;
             for(int j = 0; j < tmp.childNodes.size(); j ++){
                 if(tmp.childNodes.get(j).nodeChar == s.charAt(i)){
                     tmp = tmp.childNodes.get(j);
                     containsChar = true;
                     break;
                 }
             }
             if(containsChar == false){
                 return false;
             }
         }
         return tmp.isWord == true;
     }

     /*
      * During delete operation we delete the key in bottom up manner using recursion. The following are possible conditions when deleting key from trie,
      * 1. Key may not be there in trie. Delete operation should not modify trie.
      * 2. Key present as unique key (no part of key contains another key (prefix), nor the key itself is prefix of another key in trie). Delete all the nodes.
      * 3. Key is prefix key of another long key in trie. Unmark the leaf node.
      * 4. Key present in trie, having atleast one other key as prefix key. Delete nodes from end of key until first leaf node of longest prefix key.
     */
     public void delete(String s){
         if(searchString(s) == false) return;
         TrieNode tmp = root;
         if(tmp.freq == 1){
             tmp.childNodes.remove(0);
             tmp.freq = 0;
             return;
         }
         for(int i = 0; i < s.length(); i ++){
             for(int j = 0; j < tmp.childNodes.size(); j ++){
                 if(tmp.childNodes.get(j).nodeChar == s.charAt(i)){
                     if(tmp.childNodes.get(j).freq == 1){
                         tmp.childNodes.remove(j);
                         tmp.freq --;
                         return;
                     }else{
                         tmp.childNodes.get(j).freq --;
                         tmp = tmp.childNodes.get(j);
                     }
                     break;
                 }
             }
         }
         tmp.isWord = false;

     }

     //find a list of string in the dictionary, which contains the longest prefix with the target string
     public List<String> findAllStringWithSameLongestPrefix(String s){
         Prefix tmp = findLongestPrefix(s);
         List<String> result = new ArrayList<String>();
         if(tmp.root.equals(root)) return result;
         findAllStringInSubTree(tmp.root, new StringBuilder(tmp.prefix), result);
         return result;
     }

     private Prefix findLongestPrefix(String s){
         TrieNode tmp = root;
         StringBuilder sb = new StringBuilder();
         for(int i = 0; i < s.length(); i ++){
             Boolean containsChar = false;
             for(int j = 0; j < tmp.childNodes.size(); j ++){
                 if(tmp.childNodes.get(j).nodeChar == s.charAt(i)){
                     sb.append(s.charAt(i));
                     tmp = tmp.childNodes.get(j);
                     containsChar = true;
                     break;
                 }
             }
             if(containsChar == false){
                 return new Prefix(tmp, sb.toString());
             }
         }
         return new Prefix(tmp, s);
     }

     private void findAllStringInSubTree(TrieNode root, StringBuilder sb, List<String> result){
         if(root.isWord == true){
             result.add(sb.toString());
         }
         for(int i = 0; i < root.childNodes.size(); i ++){
             TrieNode tmp = root.childNodes.get(i);
             sb.append(tmp.nodeChar);
             findAllStringInSubTree(tmp, new StringBuilder(sb), result);
             sb.deleteCharAt(sb.length() - 1);
         }
     }

     public static void main(String[] args){
         Trie trie = new Trie();
         System.out.println("insert string into Trie:");
         System.out.println("a, aq, ab, abb, aa, bbd, bd, ba, abc");
         trie.insert("a");
         trie.insert("aq");
         trie.insert("ab");
         trie.insert("abb");
         trie.insert("aa");
         trie.insert("bbd");
         trie.insert("bd");
         trie.insert("ba");
         trie.insert("abc");
         System.out.println("search string in Trie:");
         System.out.println("abb: " + trie.searchString("abb"));
         System.out.println("bd: " + trie.searchString("bd"));
         System.out.println("bda: " + trie.searchString("bda"));
         System.out.println("strings start with a:");
         List<String> list1 = trie.findAllStringWithSameLongestPrefix("a");
         for(int i = 0; i < list1.size(); i ++){
             System.out.println(list1.get(i));
         }
         System.out.println("strings start with b:");
         List<String> list2 = trie.findAllStringWithSameLongestPrefix("b");
         for(int i = 0; list2 != null && i < list2.size(); i ++){
             System.out.println(list2.get(i));
         }
         System.out.println("strings start with ab:");
         List<String> list3 = trie.findAllStringWithSameLongestPrefix("ab");
         for(int i = 0; i < list3.size(); i ++){
             System.out.println(list3.get(i));
         }
         System.out.println("strings start with abcdef:");
         List<String> list4 = trie.findAllStringWithSameLongestPrefix("abcdef");
         for(int i = 0; list4 != null && i < list4.size(); i ++){
             System.out.println(list4.get(i));
         }
         System.out.println("delete string from trie:");
         trie.delete("ab");
         System.out.println(trie.searchString("ab"));
         System.out.println(trie.searchString("abb"));
     }
 }

Output:

insert string into Trie:
a, aq, ab, abb, aa, bbd, bd, ba, abc
search string in Trie:
abb: true
bd: true
bda: false
strings start with a:
a
aq
ab
abb
abc
aa
strings start with b:
bbd
bd
ba
strings start with ab:
ab
abb
abc
strings start with abcdef:
abc
delete string from trie:
false
true