TRIER LA STRUCTURE DES DONNÉES | INSÉRER ET RECHERCHER - TECHCODEVIEW.COM

Le Essayer la structure des données est une structure de données arborescente utilisée pour stocker un ensemble dynamique de chaînes. Il est couramment utilisé pour être efficace récupération et stockage de clés dans un grand ensemble de données. La structure soutient des opérations telles que insertion , recherche , et effacement de clés, ce qui en fait un outil précieux dans des domaines tels que l'informatique et la recherche d'informations. Dans cet article, nous allons explorer insertion et recherche opération dans la structure de données Trie.

Essayer la structure des données

Table des matières

Représentation du nœud Trie
Représentation du nœud Trie :
UN Essayer la structure des données se compose de nœuds reliés par des arêtes. Chaque nœud représente un caractère ou une partie de chaîne. Le nœud racine, point de départ du Trie, représente une chaîne vide. Chaque arête émanant d'un nœud signifie un caractère spécifique. Le chemin de la racine vers un nœud représente le préfixe d'une chaîne stockée dans le Trie.

Une structure simple pour représenter les nœuds de l’alphabet anglais peut être la suivante.
C++ struct TrieNode { // pointer array for child nodes of each node TrieNode* childNode[26]; // Used for indicating ending of string bool wordEnd; TrieNode() { // constructor // initialize the wordEnd variable with false // initialize every index of childNode array with // NULL wordEnd = false; for (int i = 0; i < 26; i++) { childNode[i] = NULL; } } };Java public class TrieNode { // Array for child nodes of each node TrieNode[] childNode; // Used for indicating the end of a string boolean wordEnd; // Constructor public TrieNode() { // Initialize the wordEnd variable with false wordEnd = false; // Initialize every index of the childNode array with null childNode = new TrieNode[26]; for (int i = 0; i < 26; i++) { childNode[i] = null; } } }
Passons en revue le processus d'insertion des mots dans une structure de données Trie. Nous avons déjà couvert les bases de Trie et de sa structure de nœuds.

Voici une représentation visuelle de l'insertion des mots et et sur dans une structure de données Trie :
Insérer une opération dans la structure de données Trie

Insertion et dans la structure de données Trie :
- Commencez par le nœud racine : Le nœud racine n'a aucun caractère associé et son fin de mot La valeur est 0 , indiquant qu'aucun mot complet ne se termine à ce stade.
- Premier caractère a : Calculez l'indice en utilisant ' une' – 'une' = 0 . Vérifiez si le noeudenfant[0] est nul . Puisque c'est le cas, créez un nouveau TrieNode avec le personnage un , fin de mot mis à 0 , et un tableau vide de pointeurs. Déplacez-vous vers ce nouveau nœud.
- Deuxième caractère n : Calculez l'indice en utilisant 'n' – 'a' = 13 . Vérifier si noeudenfant[13] est nul . C'est le cas, alors créez un nouveau TrieNode avec le personnage n , fin de mot mis à 0 , et un tableau vide de pointeurs. Déplacez-vous vers ce nouveau nœud.
- Troisième caractère d : Calculez l'indice en utilisant ' d' – 'a' = 3 . Vérifier si noeudenfant[3 ] est nul . C'est le cas, alors créez un nouveau TrieNode avec le personnage d , fin de mot mis à 1 (indiquant le mot et se termine ici).
Insertion de fourmi dans la structure de données Trie :
- Commencez par le nœud racine : Le nœud racine ne contient aucune donnée mais il garde une trace de chaque premier caractère de chaque chaîne insérée.
- Premier caractère a : Calculez l'indice en utilisant ' une' – 'une' = 0 . Vérifiez si le noeudenfant[0] est nul . Nous avons déjà le un nœud créé à partir de l’insertion précédente. alors passez à l'existant un nœud.
- Premier caractère n : Calculez l'indice en utilisant ' n' – 'a' = 13 . Vérifier si noeudenfant [13] est nul . Ce n'est pas le cas, alors passez à l'existant n nœud.
- Deuxième caractère t : Calculez l'indice en utilisant 't' – 'a' = 19 . Vérifier si noeudenfant [19] est nul . C'est le cas, alors créez un nouveau TrieNode avec le personnage t , fin de mot mis à 1 (indiquant que le mot fourmi se termine ici).
Vous trouverez ci-dessous l'implémentation de l'insertion de chaînes dans la structure de données Trie :
C++ #include using namespace std; struct TrieNode { // pointer array for child nodes of each node TrieNode* childNode[26]; // Used for indicating ending of string bool wordEnd; TrieNode() { // constructor // initialize the wordEnd variable with false // initialize every index of childNode array with // NULL wordEnd = false; for (int i = 0; i < 26; i++) { childNode[i] = NULL; } } }; void insert_key(TrieNode* root, string& key) { // Initialize the currentNode pointer // with the root node TrieNode* currentNode = root; // Iterate across the length of the string for (auto c : key) { // Check if the node exist for the current // character in the Trie. if (currentNode->childNode[c - 'a'] == NULL) { // Si le nœud pour le caractère actuel n'existe pas // alors créez un nouveau nœud TrieNode* newNode = new TrieNode(); // Conserve la référence du nœud // nouvellement créé. currentNode->childNode[c - 'a'] = newNode; } // Maintenant, déplacez le pointeur du nœud actuel vers le nœud // nouvellement créé. currentNode = currentNode->childNode[c - 'a']; } // Incrémentez le wordEndCount pour le dernier pointeur // currentNode, cela implique qu'il y a une chaîne se terminant par // currentNode. currentNode->wordEnd = 1 ; }
Complexité temporelle : O(nombre de mots * maxLengthOfWord)
Espace auxiliaire : O(nombre de mots * maxLengthOfWord)
La recherche d'une clé dans la structure de données Trie est similaire à son opération d'insertion. Cependant, ce n'est que compare les personnages et descend . La recherche peut se terminer en raison de la fin d'une chaîne ou d'un manque de clé dans le trie.

Approche étape par étape pour la recherche dans la structure Trie Data :
- Commencez au nœud racine. C'est le point de départ de toutes les recherches au sein du Trie.
- Parcourez le Trie en fonction des caractères du mot que vous recherchez. Pour chaque personnage, suivez la branche correspondante dans le Trie. Si la branche n’existe pas, le mot n’est pas présent dans le Trie.
- Si vous atteignez la fin du mot et que l'indicateur wordEnd est défini sur 1, le mot a été trouvé.
- Si vous atteignez la fin du mot et que l'indicateur wordEnd est à 0, le mot n'est pas présent dans le Trie, même s'il partage un préfixe avec un mot existant.
Voici une représentation visuelle du mot recherché papa dans la structure de données Trie :
Supposons que nous ayons réussi à insérer les mots et , sur , et papa dans notre Trie, et nous devons rechercher des mots spécifiques dans la structure de données Trie. Essayons de chercher le mot papa :

Opération de recherche dans la structure de données Trie
- Nous commençons par le nœud racine.
- On suit la branche correspondant au caractère 'd'.
- On suit la branche correspondant au caractère a’.
- On suit la branche correspondant au caractère 'd'.
- Nous arrivons à la fin du mot et fin de mot le drapeau est 1 . Cela signifie que papa est présent dans le Trie.
Vous trouverez ci-dessous l'implémentation de la recherche de chaînes dans Trie Data Structure :
C++ #include using namespace std; struct TrieNode { // pointer array for child nodes of each node TrieNode* childNode[26]; // Used for indicating ending of string bool wordEnd; TrieNode() { // constructor // initialize the wordEnd variable with false // initialize every index of childNode array with // NULL wordEnd = false; for (int i = 0; i < 26; i++) { childNode[i] = NULL; } } }; bool search_key(TrieNode* root, string& key) { // Initialize the currentNode pointer // with the root node TrieNode* currentNode = root; // Iterate across the length of the string for (auto c : key) { // Check if the node exist for the current // character in the Trie. if (currentNode->childNode[c - 'a'] == NULL) { // Le mot donné n'existe pas dans Trie return false; } // Déplacez le pointeur currentNode vers le nœud // déjà existant pour le caractère actuel. currentNode = currentNode->childNode[c - 'a']; } return (currentNode->wordEnd == true); }
Complexité temporelle : O(nombre de mots * maxLengthOfWord)
Espace auxiliaire : O(nombre de mots * maxLengthOfWord)
Créez un nœud racine à l'aide de TrieNode() constructeur.
Stockez une collection de chaînes qui doivent être insérées dans le trie dans un vecteur de chaînes, par exemple : arr .
Insérer toutes les chaînes dans Trie avec l'aide du insert_key() fonction,
Rechercher des chaînes à l'aide de clé_recherche() fonction.

Vous trouverez ci-dessous la mise en œuvre de l’approche ci-dessus :

C++

  #include  using namespace std; struct TrieNode {  // pointer array for child nodes of each node  TrieNode* childNode[26];  // Used for indicating ending of string  bool wordEnd;  TrieNode()  {  // constructor  // initialize the wordEnd variable with false  // initialize every index of childNode array with  // NULL  wordEnd = false;  for (int i = 0; i  < 26; i++) {  childNode[i] = NULL;  }  } }; void insert_key(TrieNode* root, string& key) {  // Initialize the currentNode pointer  // with the root node  TrieNode* currentNode = root;  // Iterate across the length of the string  for (auto c : key) {  // Check if the node exist for the current  // character in the Trie.  if (currentNode->childNode[c - 'a'] == NULL) { // Si le nœud pour le caractère actuel n'existe pas // alors créez un nouveau nœud TrieNode* newNode = new TrieNode();  // Conserve la référence du nœud // nouvellement créé.  currentNode->childNode[c - 'a'] = newNode;  } // Maintenant, déplacez le pointeur du nœud actuel vers le nœud // nouvellement créé.  currentNode = currentNode->childNode[c - 'a'];  } // Incrémentez le wordEndCount pour le dernier pointeur // currentNode, cela implique qu'il y a une chaîne se terminant par // currentNode.  currentNode->wordEnd = 1 ; } bool search_key(TrieNode* root, string& key) { // Initialise le pointeur currentNode // avec le nœud racine TrieNode* currentNode = root;  // Itérer sur toute la longueur de la chaîne for (auto c : key) { // Vérifiez si le nœud existe pour le // caractère actuel dans le Trie.  if (currentNode->childNode[c - 'a'] == NULL) { // Le mot donné n'existe pas dans Trie return false;  } // Déplacez le pointeur currentNode vers le nœud // déjà existant pour le caractère actuel.  currentNode = currentNode->childNode[c - 'a'];  } return (currentNode->wordEnd == true); } // Code du pilote int main() { // Créer un nœud racine pour le Trie TrieNode* root = new TrieNode();  // Stocke les chaînes que nous voulons insérer dans le // vecteur Trie inputStrings = { 'et', 'ant', 'do', 'geek', 'papa', 'ball' } ;  // nombre d'opérations d'insertion dans le Trie int n = inputStrings.size();  pour (int je = 0; je < n; i++) {  insert_key(root, inputStrings[i]);  }  // Stores the strings that we want to search in the Trie  vector searchQueryStrings = { 'do', 'geek', 'bat' } ;  // nombre d'opérations de recherche dans le Trie int searchQueries = searchQueryStrings.size();  pour (int je = 0; je < searchQueries; i++) {  cout  < < 'Query String: '  < < searchQueryStrings[i]   < < '
';  if (search_key(root, searchQueryStrings[i])) {  // the queryString is present in the Trie  cout  < < 'The query string is present in the '  'Trie
';  }  else {  // the queryString is not present in the Trie  cout  < < 'The query string is not present in '  'the Trie
';  }  }  return 0; }

Java

  class TrieNode {  TrieNode[] childNode;  boolean wordEnd;  TrieNode()  {  childNode = new TrieNode[26];  wordEnd = false;  } } class Trie {  TrieNode root;  Trie() { root = new TrieNode(); }  // Function to insert a key into the Trie  void insert(String key)  {  TrieNode currentNode = root;  for (int i = 0; i  < key.length(); i++) {  int index = key.charAt(i) - 'a';  if (currentNode.childNode[index] == null) {  currentNode.childNode[index]  = new TrieNode();  }  currentNode = currentNode.childNode[index];  }  currentNode.wordEnd = true;  }  // Function to search for a key in the Trie  boolean search(String key)  {  TrieNode currentNode = root;  for (int i = 0; i  < key.length(); i++) {  int index = key.charAt(i) - 'a';  if (currentNode.childNode[index] == null) {  return false;  }  currentNode = currentNode.childNode[index];  }  return currentNode.wordEnd;  } } public class Main {  public static void main(String[] args)  {  Trie trie = new Trie();  String[] inputStrings  = { 'and', 'ant', 'do', 'geek', 'dad', 'ball' };  // Insert each string into the Trie  for (String str : inputStrings) {  trie.insert(str);  }  String[] searchQueryStrings  = { 'do', 'geek', 'bat' };  // Search for each string and print whether it is  // found in the Trie  for (String query : searchQueryStrings) {  System.out.println('Query String: ' + query);  if (trie.search(query)) {  System.out.println(  'The query string is present in the Trie');  }  else {  System.out.println(  'The query string is not present in the Trie');  }  }  } }

Python

  class TrieNode: def __init__(self): self.childNode = [None] * 26 self.wordEnd = False class Trie: def __init__(self): self.root = TrieNode() # Function to insert a key into the Trie def insert(self, key): currentNode = self.root for char in key: index = ord(char) - ord('a') if not currentNode.childNode[index]: currentNode.childNode[index] = TrieNode() currentNode = currentNode.childNode[index] currentNode.wordEnd = True # Function to search for a key in the Trie def search(self, key): currentNode = self.root for char in key: index = ord(char) - ord('a') if not currentNode.childNode[index]: return False currentNode = currentNode.childNode[index] return currentNode.wordEnd if __name__ == '__main__': trie = Trie() inputStrings = ['and', 'ant', 'do', 'geek', 'dad', 'ball'] # Insert each string into the Trie for word in inputStrings: trie.insert(word) searchQueryStrings = ['do', 'geek', 'bat'] # Search for each string and print whether it is found in the Trie for query in searchQueryStrings: print('Query String:', query) if trie.search(query): print('The query string is present in the Trie') else: print('The query string is not present in the Trie')

Javascript

  class TrieNode {  constructor() {  // Initialize the childNode array with 26 nulls  this.childNode = Array(26).fill(null);  // Initialize wordEnd to the false indicating that no word ends here yet  this.wordEnd = false;  } } class Trie {  constructor() {  // Initialize the root node of the Trie  this.root = new TrieNode();  }  // Function to insert a key into the Trie  insert(key) {  // Start from the root node  let currentNode = this.root;  for (let i = 0; i  < key.length; i++) {  const index = key.charCodeAt(i) - 'a'.charCodeAt(0);  if (currentNode.childNode[index] === null) {  currentNode.childNode[index] = new TrieNode();  }  // Move to the next node in the Trie  currentNode = currentNode.childNode[index];  }  // Mark the end of the word  currentNode.wordEnd = true;  }  // Function to search for a key in the Trie  search(key) {  // Start from the root node  let currentNode = this.root;  // Iterate through each character in the key  for (let i = 0; i  < key.length; i++) {  const index = key.charCodeAt(i) - 'a'.charCodeAt(0);  if (currentNode.childNode[index] === null) {  return false;  }  // Move to the next node in the Trie  currentNode = currentNode.childNode[index];  }  // Return true if the end of the word is marked otherwise false  return currentNode.wordEnd;  } } // Driver code const trie = new Trie(); const inputStrings = ['and', 'ant', 'do', 'geek', 'dad', 'ball']; // Insert each string into the Trie inputStrings.forEach((str) =>trie.insert(str)); const searchQueryStrings = ['do', 'geek', 'bat']; // Recherchez chaque chaîne et affichez si elle est trouvée dans le Trie searchQueryStrings.forEach((query) => { console.log(`Query String: ${query}`); if (trie.search(query)) { console.log('La chaîne de requête est présente dans le Trie'); } else { console.log('La chaîne de requête n'est pas présente dans le Trie' } });

Sortir

Query String: do The query string is present in the Trie Query String: geek The query string is present in the Trie Query String: bat The query string is not present in the Trie