trie（字典树）原理及C++代码实现

字典树，又称前缀树，是用于存储大量字符串或类似数据的数据结构。

它的原理是利用相同前缀来减少查询字符串的时间。

不同于BST把关键字保存在本结点中，TRIE可以想象成把关键字和下一个结点的指针绑定，事实上我也是用map来实现的，所以不熟悉map的提前熟悉map的操作。

Tire的逻辑比较抽象，所以如果是第一次见到这种组织方式的建议先熟悉熟悉这种逻辑再开始写代码，这样会比较顺畅。

代码如下：（仅供参考）

struct Node {
public :
    bool isWord;
    unordered_map<char, Node*> next;
public :
    Node(bool Isword = false) : isWord(Isword) {}
};

class Trie {
    Node root;
    int size;

public :
    Trie() : size(0) {}
    int getSize() {return size;}
    void add(string word);  //添加一个新单词
    bool contains(string word); //查询是否有该单词
    bool isPrefix(string prefix); //查询是否有单词以该prefix为前缀
    void del(string word);  //删除一个单词
};

void Trie::add(string word) {
    Node *curr = &root;

    for (int i = 0; i < word.length(); ++i) {
        Node* ptr = nullptr;
        auto ret = curr->next.insert({word[i], ptr});
        if (ret.second)
            ret.first->second = new Node();
        curr = ret.first->second;
    }

    if (!curr->isWord) {
        curr->isWord = true;
        ++size;
    }
}

bool Trie::contains(string word) {
    const Node *curr = &root;

    for (int i = 0; i < word.length(); ++i) {
        auto ret = curr->next.find(word[i]);

        if (ret == curr->next.end()) {
            return false;
        }
        curr = ret->second;
    }
    return curr->isWord;
}

bool Trie::isPrefix(string prefix) {
    const Node *curr = &root;

    for (int i = 0; i < prefix.length(); ++i) {
        auto ret = curr->next.find(prefix[i]);

        if (ret == curr->next.end()) {
            return false;
        }
        curr = ret->second;
    }
    return true;
}

void Trie::del(string word) {
    if (!contains(word))
        return ;

    vector<Node*> preNode;
    Node *curr = &root;

    for (int i = 0; i < word.length(); ++i) {
        preNode.push_back(curr);
        curr = curr->next.find(word[i])->second;
    }
    if (curr->next.size() == 0) {
        for (int i = word.length() - 1; i >= 0 ; --i) {
            Node *pre = preNode.back();
            preNode.pop_back();

            if ((i != word.length() - 1) && (curr->isWord || curr->next.size() != 0))
                break;
            delete curr;
            pre->next.erase(word[i]);
            curr = pre;
        }
    } else {
        curr->isWord = false;
    }
    --size;
}