📌  相关文章
📜  如何使用三元搜索树实现文本自动完成功能

📅  最后修改于: 2021-06-26 15:18:25             🧑  作者: Mango

给定一组字符串S和一个字符串patt ，任务是使用三元搜索树将字符串patt自动完成为来自S的以patt为前缀的字符串。如果没有字符串与给定的前缀匹配，则打印“ None” 。

例子：

Trie方法：请参考本文，以了解使用Trie数据结构的实现。

三元搜索树方法请按照以下步骤解决问题：

  • 根据以下条件，将S中字符串的所有字符插入三进制搜索树：
    1. 如果要插入的字符小于当前节点值，请遍历左子树。
    2. 如果要插入的字符大于当前节点值，请遍历右子树。
    3. 如果要插入的字符与当前节点值的字符相同，请遍历相等的子树(如果它不是单词的结尾)。如果是这样，请将节点标记为单词的结尾。
  • 请遵循类似的方法来提取建议。
  • 按照与上述类似的遍历技术遍历树以搜索给定的前缀patt 。
  • 如果找不到给定的前缀，则打印“无”。
  • 如果找到给定的前缀，请从前缀结束的节点遍历树。遍历左子树并生成建议，然后从每个节点生成正确的和相等的子树。
  • 每次遇到设置了endofWord变量的节点，都表示已获得建议。将该建议插入文字中。
  • 生成所有可能的建议后，请返回单词。

下面是上述方法的实现：

C++
// C++ Program to generate
// autocompleted texts from
// a given prefix using a
// Ternary Search Tree
#include 
using namespace std;
  
// Define the Node of the
// tree
struct Node {
  
    // Store the character
    // of a string
    char data;
    // Store the end of
    // word
    int end;
    // Left Subtree
    struct Node* left;
  
    // Equal Subtree
    struct Node* eq;
  
    // Right Subtree
    struct Node* right;
};
  
// Function to create a Node
Node* createNode(char newData)
{
    struct Node* newNode = new Node();
    newNode->data = newData;
    newNode->end = 0;
    newNode->left = NULL;
    newNode->eq = NULL;
    newNode->right = NULL;
    return newNode;
}
  
// Function to insert a word
// in the tree
void insert(Node** root,
            string word,
            int pos = 0)
{
  
    // Base case
    if (!(*root))
        *root = createNode(word[pos]);
  
    // If the current character is
    // less than root's data, then
    // it is inserted in the
    // left subtree
  
    if ((*root)->data > word[pos])
        insert(&((*root)->left), word,
               pos);
  
    // If current character is
    // more than root's data, then
    // it is inserted in the right
    // subtree
  
    else if ((*root)->data < word[pos])
        insert(&((*root)->right), word,
               pos);
  
    // If current character is same
    // as that of the root's data
  
    else {
        // If it is the end of word
  
        if (pos + 1 == word.size())
            // Mark it as the
            // end of word
            (*root)->end = 1;
  
        // If it is not the end of
        // the string, then the
        // current character is
        // inserted in the equal subtree
  
        else
            insert(&((*root)->eq), word, pos + 1);
    }
}
  
// Function to traverse the ternary search tree
void traverse(Node* root,
              vector& ret,
              char* buff,
              int depth = 0)
{
    // Base case
    if (!root)
        return;
    // The left subtree is
    // traversed first
    traverse(root->left, ret,
             buff, depth);
  
    // Store the current character
    buff[depth] = root->data;
  
    // If the end of the string
    // is detected, store it in
    // the final ans
    if (root->end) {
        buff[depth + 1] = '\0';
        ret.push_back(string(buff));
    }
  
    // Traverse the equal subtree
    traverse(root->eq, ret,
             buff, depth + 1);
  
    // Traverse the right subtree
    traverse(root->right, ret,
             buff, depth);
}
  
// Utility function to find
// all the words
vector util(Node* root,
                    string pattern)
{
    // Stores the words
    // to suggest
    char buffer[1001];
  
    vector ret;
  
    traverse(root, ret, buffer);
  
    if (root->end == 1)
        ret.push_back(pattern);
    return ret;
}
  
// Function to autocomplete
// based on the given prefix
// and return the suggestions
vector autocomplete(Node* root,
                            string pattern)
{
    vector words;
    int pos = 0;
  
    // If pattern is empty
    // return an empty list
    if (pattern.empty())
        return words;
  
    // Iterating over the characters
    // of the pattern and find it's
    // corresponding node in the tree
  
    while (root && pos < pattern.length()) {
  
        // If current character is smaller
        if (root->data > pattern[pos])
            // Search the left subtree
            root = root->left;
  
        // current character is greater
        else if (root->data < pattern[pos])
            // Search right subtree
            root = root->right;
  
        // If current character is equal
        else if (root->data == pattern[pos])
            // Search equal subtree
            root = root->eq;
  
        // If not found
        else
            return words;
  
        pos++;
    }
  
    // Search for all the words
    // from the current node
    words = util(root, pattern);
  
    return words;
}
  
// Function to print
// suggested words
  
void print(vector sugg,
           string pat)
{
    for (int i = 0; i < sugg.size();
         i++)
        cout << pat << sugg[i].c_str()
             << "\n";
}
  
// Driver Code
int main()
{
    vector S
        = { "wallstreet", "geeksforgeeks",
            "wallmart", "walmart",
            "waldormort", "word" };
  
    Node* tree = NULL;
  
    // Insert the words in the
    // Ternary Search Tree
    for (string str : S)
        insert(&tree, str);
  
    string pat = "wall";
  
    vector sugg
        = autocomplete(tree, pat);
  
    if (sugg.size() == 0)
        cout << "None";
  
    else
        print(sugg, pat);
  
    return 0;
}

输出： 
wallmart
wallstreet