LeetCode——Add and Search Word - Data structure design

Description:

Design a data structure that supports the following two operations:

void addWord(word)
bool search(word)

search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one letter.

For example:

addWord("bad")
addWord("dad")
addWord("mad")
search("pad") -> false
search("bad") -> true
search(".ad") -> true
search("b..") -> true

Note:
You may assume that all words are consist of lowercase letters a-z.

题目很好理解：添加单词查找单词。

首先想到的是用线性数据结构，然后逐个匹配查找。可以想象一定是超时的。

 public class WordDictionary {

     private List<String> arr = new ArrayList<String>();

     // Adds a word into the data structure.
     public void addWord(String word) {
         arr.add(word);
     }

     // Returns if the word is in the data structure. A word could
     // contain the dot character '.' to represent any one letter.
     public boolean search(String word) {
         boolean flag = true;
         for(String str : arr) {
             if(str.equals(word)) {
                 flag = true;
                 break;
             }
             else if(arr.contains(".")) {
                 if(word.length() != str.length()) {
                     flag = false;
                     break;
                 }

                 for(int i=0; i<str.length();) {
                     char ch1 = str.charAt(i);
                     char ch2 = word.charAt(i);
                     if(ch1 == '.' || ch2 == '.' || ch1 == ch2) {
                         i ++;
                     }
                     else {
                         flag = false;
                         break;
                     }
                 }

             }
             else {
                 flag = false;
                 break;
             }
         }
         return flag;
     }
 }

 // Your WordDictionary object will be instantiated and called as such:
 // WordDictionary wordDictionary = new WordDictionary();
 // wordDictionary.addWord("word");
 // wordDictionary.search("pattern");

要优化明显要使用Trie树来减少无用的比较次数，从而降低时间复杂度。

关于Trie树：http://www.cnblogs.com/wxisme/p/4876197.html

public class WordDictionary {

    private TrieNode root;

    public WordDictionary() {
        this.root = new TrieNode();
    }

    private class TrieNode {
        private TrieNode[] son;
        private char val;
        private boolean isEnd;
        public TrieNode() {
            this.son = new TrieNode[26];
            this.isEnd = false;
        }
    }

    // Adds a word into the data structure.
    public void addWord(String word) {

        char[] wordChars = word.toCharArray();
        TrieNode node = this.root;

        for(char ch : wordChars) {
            int pos = ch - 'a';
            if(node.son[pos] == null) {
                node.son[pos] = new TrieNode();
                node.son[pos].val = ch;
            }
            node = node.son[pos];
        }
        node.isEnd = true;
    }

    public boolean patternSearch(String word, TrieNode node) {
        char[] wordChars = word.toCharArray();
        for(int at=0; at<word.length(); at++) {
            char ch = wordChars[at];
            if(ch != '.') {
                int pos = ch - 'a';
                if(node.son[pos] != null) {

                    node = node.son[pos];
                }
                else {
                    return false;
                }
            }
            else {
                int flag = 0;
                for(int i=0; i<26; i++) {
                    if(node.son[i] != null) {
                        boolean b =patternSearch(word.substring(at+1), node.son[i]);
                        if(b) return b;
                        else {
                            flag ++;
                        }
                    }
                    else {
                        flag ++;
                        continue;
                    }
                }
                if(flag == 26) {
                    return false;
                }
            }
        }
        return node.isEnd;
    }

    // Returns if the word is in the data structure. A word could
    // contain the dot character '.' to represent any one letter.
    public boolean search(String word) {

        return patternSearch(word, this.root);
    }

}