Trie

最新推荐文章于 2021-10-06 16:51:19 发布

随心而至

最新推荐文章于 2021-10-06 16:51:19 发布

阅读量531

点赞数

分类专栏： LeetCode 文章标签： Trie-树 LeetCode C++

本文链接：https://blog.csdn.net/novostary/article/details/48196491

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

只要把数据结构想清楚了，其实 Trie 树很简单的。

摘自百度百科

字典树，又称单词查找树。利用字符串的公共前缀来减少查询时间。

典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。

它有3个基本性质：

根节点不包含字符，除根节点外每一个节点都只包含一个字符；
从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串；
每个节点的所有子节点包含的字符都不相同。

Implement Trie (Prefix Tree)

https://leetcode.com/problems/implement-trie-prefix-tree/

Implement a trie with insert, search, and startsWith methods.

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

TrieNode 包含三个变量，当前结点所对应的字符，当前结点是否为单词（本题中，由于可以用位置代表当前字符，所以，该变量不是必须的，下面的实现中其实也没有用到），当前结点的孩子结点（用指针数组来表示，大小已定）。还可以考虑删除操作，以及重复插入的情况。

next 有不同的实现方式。

TrieNode* next[26]; // fast, Runtime: 56 ms
memset(next, 0, sizeof(TrieNode*)* 26); // initialize
vector<TrieNode*> children; // middle, Runtime: 108 ms
children(vector<TrieNode*>(26, nullptr)) // initialize
unordered_map<char, TrieNode*> next; // slow, Runtime: 188 ms without deconstruct, 228 ms with deconstruct

Trie 记录树根，提供相关服务。search 和 startsWith 的大部分内容是一样的，故提取出 find 函数。

#include <string>
using std::string;

// Runtime: 64 ms with destructor
// Runtime: 56 ms without destructor

// https://leetcode.com/discuss/34832/two-c-o-n-solutions-array-or-hashtable

class TrieNode {
public:
    // Initialize your data structure here.
    TrieNode() : c(0), isWord(false) {
        memset(next, 0, sizeof(TrieNode*)* 26);
    }
    TrieNode(char _c) : c(_c), isWord(false) {
        memset(next, 0, sizeof(TrieNode*)* 26);
    }
    ~TrieNode() {
        delete []next;
    }
    TrieNode* next[26];
    char c;
    bool isWord;
};

class Trie {
public:
    Trie() {
        root = new TrieNode();
    }
    ~Trie() {
        destroy(root);
    }
    void destroy(TrieNode* node) {
        for (int i = 0; i < 26; i++) {
            if (node->next[i]) {
                destroy(node->next[i]);
            }
        }
        delete node;
    }
    // Inserts a word into the trie.
    void insert(string word) {
        TrieNode* p = root;
        for (auto ch : word) {
            int index = ch - 'a';
            if (!p->next[index]) {
                p->next[index] = new TrieNode(ch);
            }
            p = p->next[index];
        }
        p->isWord = true;
    }

    // Returns if the word is in the trie.
    bool search(string word) {
        TrieNode* p = find(word);
        return p && p->isWord;
    }

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    bool startsWith(string prefix) {
        return find(prefix) != nullptr;
    }

private:
    TrieNode* find(string key) {
        TrieNode* p = root;
        for (auto ch : key) {
            p = p->next[ch - 'a'];
            if (!p) {
                break;
            }
        }
        return p;
    }
    TrieNode* root;
};

// Your Trie object will be instantiated and called as such:
// Trie trie;
// trie.insert("somestring");
// trie.search("key");

Add and Search Word - Data structure design

https://leetcode.com/problems/add-and-search-word-data-structure-design/

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.

#include <string>
using std::string;
// Runtime: 76 ms
// we doesn't need a character c.
class TrieNode{
public:
    // Initialize your data structure here.
    TrieNode() : isWord(false) {
        memset(next, 0, sizeof(TrieNode*)* 26);
    }
    TrieNode(char _c) : c(_c), isWord(false) {
        memset(next, 0, sizeof(TrieNode*)* 26);
    }
    ~TrieNode() {
        delete []next;
    }
    TrieNode* next[26];
    char c;
    bool isWord;
};
class WordDictionary {
public:
    WordDictionary() {
        root = new TrieNode();
    }
    // Adds a word into the data structure.
    void addWord(string word) {
        TrieNode* p = root;
        for (auto ch : word) {
            int index = ch - 'a';
            if (!p->next[index]) {
            //if (p->next[index] == nullptr) {
                p->next[index] = new TrieNode(ch);
            }
            p = p->next[index];
        }
        p->isWord = true;
    }

    // Returns if the word is in the data structure. A word could
    // contain the dot character '.' to represent any one letter.
    bool search(string word) {
        return searchHelper(word.c_str(), root);
    }

private:
    //bool searchHelper(const char* word, TrieNode* node) {
    //  for (int i = 0; word[i]; i++) {
    //      if (node && word[i] != '.') {
    //          node = node->next[word[i] - 'a'];
    //      }
    //      else if (node && word[i] == '.') {
    //          for (int j = 0; j < 26; j++) {
    //              if (searchHelper(word + i + 1, node->next[j])) {
    //                  return true;
    //              }
    //          }
    //          // 'a', search(".a") or search("a.")
    //          return false;
    //      }
    //      else {
    //          break;
    //      }
    //  }
    //  return node && node->isWord;
    //}
    bool searchHelper(const char* word, TrieNode* node) {
        // Runtime: 80 ms
        if (!node) {
            return false;
        }
        if (*word == '\0') {
            return node->isWord;
        }
        else if (*word == '.') {
            for (int j = 0; j < 26; j++) {
                if (searchHelper(word + 1, node->next[j])) {
                    return true;
                }
            }
            return false;
        }
        else {
            return searchHelper(word + 1, node->next[*word - 'a']);
        }
    }
    TrieNode* root;
};

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

Word Search II

https://leetcode.com/problems/word-search-ii/

Given a 2D board and a list of words from the dictionary, find all words in the board.

#include <string>
#include <vector>
#include <set>
#include <unordered_map>
using std::string;
using std::vector;
using std::set;
using std::unordered_map;
// Runtime: 52 ms void insert(string word, int i)
// Best: 48 ms  void insert(vector<string>& words, int i)
class TrieNode {
public:
    TrieNode() : isWord(false), isUsed(false), index(-1) {
        memset(next, 0, sizeof(TrieNode*)* 26);
    }
    TrieNode* next[26];
    bool isWord;
    bool isUsed;
    int index;
};

class Trie {
public:
    Trie() {
        root = new TrieNode();
    }
    void insert(string word, int i) {
        TrieNode* p = root;
        for (auto ch : word) {
            if (!p->next[ch - 'a']) {
                p->next[ch - 'a'] = new TrieNode();
            }
            p = p->next[ch - 'a'];
        }
        p->isWord = true;
        p->isUsed = false;
        p->index = i;
    }
    void insert(vector<string>& words, int i) {
        TrieNode* p = root;
        for (auto ch : words[i]) {
            if (!p->next[ch - 'a']) {
                p->next[ch - 'a'] = new TrieNode();
            }
            p = p->next[ch - 'a'];
        }
        p->isWord = true;
        p->isUsed = false;
        p->index = i;
    }
    void insert(vector<string>& words) {
        for (int i = 0; i < words.size(); i++) {
            // insert(words[i], i);
            insert(words, i);
        }
    }
    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> ret;
        const int ROW = board.size();
        const int COL = board[0].size();
        for (int i = 0; i < ROW; i++) {
            for (int j = 0; j < COL; j++) {
                findWords(ret, words, root, board, i, j, ROW, COL);
            }
        }
        return ret;
    }
    void findWords(vector<string>& ret, vector<string>& words, TrieNode* node, vector<vector<char>>&board, int i, int j, const int Row, const int Col) {
        // doesn't need count, because node->next[index] will be nullptr.
        // 60 ms
        if (board[i][j] == '.') {
            return;
        }
        int index = board[i][j] - 'a';
        TrieNode* next = node->next[index];
        if (next) {
            char tmp = board[i][j];
            if (next->isWord && !next->isUsed) {
                ret.push_back(words[next->index]);
                next->isUsed = true;
            }
            board[i][j] = '.';
            if (i > 0) {
                findWords(ret, words, next, board, i - 1, j, Row, Col);
            }
            if (i + 1 < Row) {
                findWords(ret, words, next, board, i + 1, j, Row, Col);
            }
            if (j > 0) {
                findWords(ret, words, next, board, i, j - 1, Row, Col);
            }
            if (j + 1 < Col) {
                findWords(ret, words, next, board, i, j + 1, Row, Col);
            }
            board[i][j] = tmp;
        }
    }
private:
    TrieNode* root;
};

class Solution {
public:
    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> ret;
        if (board.empty() || board[0].empty()) {
            return ret;
        }
        Trie trie;
        trie.insert(words);
        return trie.findWords(board, words);
    }
};