字典树(前缀树)_tree[] a=new tree[26]-CSDN博客

代码实现：

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int MAX_NODE = 1000000 + 10;
const int CHARSET = 26;
int trie[MAX_NODE][CHARSET] = {0};
int color[MAX_NODE] = {0};
int k = 1;

void insert(char *w){
    int len = strlen(w);
    int p = 0;
    for(int i=0; i<len; i++){
        int c = w[i] - 'a';
        if(!trie[p][c]){
            trie[p][c] = k;
            k++;
        }
        p = trie[p][c];
    }
    color[p] = 1;
}

int search(char *s){
    int len = strlen(s);
    int p = 0;
    for(int i=0; i<len; i++){
        int c = s[i] - 'a';
        if(!trie[p][c]) return 0;
        p = trie[p][c];
    }
    return color[p] == 1;
}

int main(){
    int t,q;
    char s[20];
    scanf("%d%d", &t,&q);
    while(t--){
        scanf("%s", s);
        insert(s);
    }
    while(q--){
        scanf("%s", s);
        if(search(s)) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

leetcode: 211. 添加与搜索单词 - 数据结构设计

解题思路
①由于有‘.’的出现，所以无法进行常规匹配，此时想到使用字典树。
②定义Tree类，用来存储每个节点，同时，因为‘.’的存在，每个节点都可能有26个孩子，同时，用isOver标志来表示当前的字符是否为一个单词的结束。
③生成树见代码注释。
④对于每一个查询，我们进行dfs的递归查询，每当遇到‘.’时，进行遍历，若命中直接返回true。
⑤具体递归过程见注释。

代码

class WordDictionary {

    /** Initialize your data structure here. */
    //字典树的头部节点
    Tree root;
    public WordDictionary() {
        root = new Tree();
    }
    
    public void addWord(String word) {
        //防止破坏头部节点，新定义一个head
        Tree head = root;
        for(char c : word.toCharArray()){
            int t = c - 'a';
            //当子节点不存在该字符时，新生成一个子节点
            if(head.nums[t] == null){
                head.nums[t] = new Tree();
            }
            //指向子节点
            head = head.nums[t];
        }
        //最后的head对应的就是该单词最后的字符，此时结束符为true，表示存在一个以该字符结尾的单词
        head.isOver = true;
    }
    
    public boolean search(String word) {
        Tree head = root;
        return dfs(word , 0 , head);
    }

    public boolean dfs(String word , int index , Tree head){
        //当遍历到所查询单词末尾时，刚好该字符为结束符，即查询命中，返回true，否则返回false
        if(index == word.length()){
            if(head.isOver) return true;
            return false;
        }
        char c = word.charAt(index);
        //遇到‘.’进行26个子节点的遍历，子节点不为null则进行递归，命中一次直接返回true
        if(c == '.'){
            for(int i = 0 ; i < 26 ; i++){
                if(head.nums[i] != null){
                    if(dfs(word , index+1 , head.nums[i])) return true;
                }
            }
        }else{
            //定向寻找，当对应子节点为null时直接返回false，否则进行递归
            int t = c - 'a';
            if(head.nums[t] != null){
                if(dfs(word , index+1 , head.nums[t])) return true;
            }
        }
        return false;
    }
}

class Tree{
    //子节点集合，对应26个英文字母，大小为26
    Tree[] nums;
    //单词结束符，用来判断截至到该节点的单词是否存在
    boolean isOver = false;
    public Tree(){
        nums = new Tree[26];
    }
}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */