📜  递归插入Trie

📅  最后修改于: 2021-04-29 03:18:04             🧑  作者: Mango

Trie是一种有效的信息检索数据结构。使用Trie,可以使搜索复杂度达到最佳极限(密钥长度)。
给定多个字符串。任务是使用递归将字符串插入到Trie中。
例子:

Input : str = {"cat", "there", "caller", "their", "calling"}
Output : caller
         calling
         cat
         there
         their

                                       root
                                      /     \    
                                     c       t     
                                     |       |     
                                     a       h     
                                     | \     |     
                                     l  t    e      
                                     |       |  \
                                     l       i   r
                                     | \     |   |
                                     e  i    r   e
                                     |  |
                                     r  n
                                        |
                                        g 

Input : str = {"Candy", "cat", "Caller", "calling"}
Output : caller
         calling
         candy
         cat
                                        root
                                         |    
                                         c            
                                         |            
                                         a            
                                      /   | \        
                                     l    n  t       
                                     |    |       
                                     l    d       
                                     | \  |      
                                     e  i y      
                                     |  |
                                     r  n
                                        |
                                        g

方法:一种有效的方法是将输入键的每个字符都视为一个单独的Trie节点,并将其插入到Trie中。请注意,子级是指向下一级Trie节点的指针(或引用)的数组。关键字符充当子数组的索引。如果输入键是新键或现有键的扩展,则需要构造键的不存在节点,并将单词的结尾标记为最后一个节点。如果输入键是Trie中现有键的前缀,我们只需将键的最后一个节点标记为单词的结尾即可。密钥长度决定了Trie深度。
下面是上述方法的实现:

CPP
#include
using namespace std;
# define CHILDREN 26
# define MAX 100
 
// Trie node
struct trie
{
    trie *child[CHILDREN];
   
    // endOfWord is true if the node represents
    // end of a word
    bool endOfWord;
};
 
// Function will return the new node(initialized to NULLs)
trie* createNode()
{
    trie *temp = new trie();
    temp->endOfWord = false;
    for(int i = 0 ; i < CHILDREN ; i++)
    {
        // Initially , initialize null to the all child
        temp->child[i] = NULL;
    }
    return temp;
}
 
// Function will insert the string in a trie recursively
void insertRecursively(trie* itr, string str, int i)
{
    if(i < str.length())
    {
        int index = str[i] - 'a';
        if(itr->child[index] == NULL )
        {
          // Create a new node
          itr->child[index] = createNode();
        }
         
      // Recursive call for insertion of string
      insertRecursively(itr->child[index], str, i + 1);
    }
    else
    {
                // Make the endOfWord true which represents
                // the end of string
        itr->endOfWord = true;
    }
}
 
// Function call to insert a string
void insert(trie* itr, string str)
{
        // Function call with necessary arguments
    insertRecursively(itr, str, 0);
 
}
 
// Function to check whether the node is leaf or not
bool isLeafNode(trie* root)
{
    return root->endOfWord != false;
}
 
// Function to display the content of trie
void displayContent(trie* root, char str[], int level)
{
    // If node is leaf node, it indicates end
    // of string, so a null character is added
    // and string is displayed
    if (isLeafNode(root))
    {
            // Assign a null character in temporary string
        str[level] = '\0';
        cout << str << endl;
    }
 
    for (int i = 0; i < CHILDREN; i++)
    {
        // If NON NULL child is found
        // add parent key to str and
        // call the display function recursively
        // for child node
        if (root->child[i])
        {
            str[level] = i + 'a';
            displayContent(root->child[i], str, level + 1);
        }
    }
}
 
// Function call for displaying content
void display(trie* itr)
{
    int level = 0;
    char str[MAX];
 
    // Function call with necessary arguments
    displayContent(itr, str, level);
}
 
// Driver code
int main()
{
    trie *root = createNode();
    insert(root, "thier");
    insert(root, "there");
    insert(root, "answer");
    insert(root, "any");
 
     
    /* After inserting strings, trie will look like
                                        root
                                        / \
                                        a     t    
                                        |     |    
                                        n     h    
                                        | \ |
                                        s y e    
                                        |     | \
                                        w     i r
                                        |     | |
                                        e     r e
                                        |    
                                        r
    */   
     
    display(root);
 
    return 0;   
}


Python3
# Python3 program to traverse in bottom up manner
CHILDREN = 26
MAX = 100
 
# Trie node
class trie:
 
    def __init__(self):
        self.child = [None for i in range(CHILDREN)]
         
        # endOfWord is true if the node represents
        # end of a word
        self.endOfWord = False
 
# Function will return the new node(initialized to NULLs)
def createNode():
 
    temp = trie()
    return temp
 
# Function will insert the string in a trie recursively
def insertRecursively(itr, str, i):
 
    if(i < len(str)):
     
        index = ord(str[i]) - ord('a')
         
        if(itr.child[index] == None ):
         
            # Create a new node
            itr.child[index] = createNode();
         
        # Recursive call for insertion of string
        insertRecursively(itr.child[index], str, i + 1);
     
    else:
     
        # Make the endOfWord true which represents
        # the end of string
        itr.endOfWord = True;
     
# Function call to insert a string
def insert(itr, str):
 
    # Function call with necessary arguments
    insertRecursively(itr, str, 0);
   
# Function to check whether the node is leaf or not
def isLeafNode(root):
 
    return root.endOfWord != False;
  
# Function to display the content of trie
def displayContent(root, str, level):
 
    # If node is leaf node, it indicates end
    # of string, so a null character is added
    # and string is displayed
    if (isLeafNode(root)):
     
        # Assign a null character in temporary string
        print(''.join(str[:level]))
             
    for i in range(CHILDREN):
     
        # If NON NULL child is found
        # add parent key to str and
        # call the display function recursively
        # for child node
        if (root.child[i]):
         
            str[level] = chr(i + ord('a'))
            displayContent(root.child[i], str, level + 1);
         
# Function call for displaying content
def display(itr):
 
    level = 0;
    str = ['' for i in range(MAX)];
  
    # Function call with necessary arguments
    displayContent(itr, str, level);
    
# Driver code
if __name__=='__main__':
     
    root = createNode();
    insert(root, "thier");
    insert(root, "there");
    insert(root, "answer");
    insert(root, "any");
  
    ''' After inserting strings, trie will look like
                                        root
                                        / \
                                        a     t    
                                        |     |    
                                        n     h    
                                        | \ |
                                        s y e    
                                        |     | \
                                        w     i r
                                        |     | |
                                        e     r e
                                        |    
                                        r
    '''
      
    display(root);
  
# This code is contributed by rutvik_56


输出:

answer
any
there
their