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);
    }

}