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