Comment utiliser les structures de données à la rouille

Rust utilise la bibliothèque des collections pour soutenir et implémenter plusieurs structures de données communes. Une collection fait référence à une collection d'une ou plusieurs valeurs stockées dans la mémoire du tas. Cela signifie que la taille de la collection n'a pas besoin d'être connue avant la compilation.

Les collections sont très utiles lors de la mise en œuvre du stockage de données flexibles et générique. La plupart des collections peuvent rétrécir ou se développer dans le programme.

Explorons diverses structures de données dans le langage de programmation de rouille et comment effectuer les opérations de base.

Ici, nous avons les quatre grandes catégories pour les collections de rouille:

1. Séquences
2. Plans
3. Sets
4. Mission

Discutons de chaque catégorie en détail.

Collections de séquences

Ici, nous discuterons des trois types de collections de séquences à Rust:

1. Vec
2. Vecdeque
3. Listin lié

Vec

Un VEC ou Vector est un tableau grand continu qui stocke les valeurs dans une liste, l'une après l'autre dans la mémoire.

Pour créer un nouveau vecteur vide, utilisez la nouvelle méthode comme indiqué ci-dessous:

Laissez mut vec = vec :: new ();

Ensuite, vous pouvez ajouter des éléments au vecteur à l'aide de la méthode push:

vec.push (1);
vec.push (2);

Pour imprimer un vecteur, utilisez le trait de débogage comme indiqué ci-dessous:

println!(":? ", vec);

Retirez l'élément dans un vecteur à l'aide de la méthode de suppression et de l'index de l'élément à supprimer, comme indiqué ci-dessous:

Vec.retirer (0); // supprimer l'élément à l'index 0
println!(":? ", vec);

Vecdeque

Un vecteur vecdeque ou double extrémité est un tampon à anneau de croissance non contigu. Nous pouvons créer un nouveau tampon vide en utilisant la nouvelle méthode comme indiqué ci-dessous:

Utilisez STD :: Collections :: VecDeque;
Laissez mut deque = vecdeque :: new ();

Le VecDeque utilise des méthodes push_front () et push_back () pour ajouter des éléments à l'avant ou à l'arrière du deque:

Se débarrasser.push_front (1);
se débarrasser.push_front (2);
se débarrasser.push_front (3);
// repousser
se débarrasser.push_back (4);
se débarrasser.push_back (5);

Pour imprimer les éléments de la vecdeque, utilisez le trait de débogage:

Println!(":? ", deque);

Pour supprimer les éléments d'un vecdeque, utilisez les méthodes pop_front () et pop_back () pour supprimer respectivement un élément de l'avant et de l'arrière du deque.

L'exemple suivant est fourni ci-dessous:

se débarrasser.pop_back ();
se débarrasser.pop_front ();
println!(":? ", deque);

Cela devrait revenir comme indiqué ci-dessous:

[3, 2, 1, 4, 5]
[2, 1, 4]

Listin lié

Ceci est une liste doublement liée aux nœuds possédés. Il est utile lorsque vous avez besoin d'un vecteur ou d'un désolement de taille inconnue.

Pour créer une nouvelle liste liée vide, utilisez ce qui suit:

Utilisez Std :: Collections :: LinkedList;
let mut lnk = linkedList :: new ();

Nous utilisons les méthodes push_front () et push_back () pour ajouter des éléments à l'avant et à l'arrière d'une liste liée, respectivement.

Par exemple:

let mut lnk = linkedList :: new ();
LNK.push_front (3);
LNK.push_front (2);
LNK.push_front (1);
LNK.push_back (4);
LNK.push_back (5);
println!(":? ", lnk);

L'exemple précédent doit revenir comme suit:

[1, 2, 3, 4, 5]

Pour supprimer les éléments d'une liste liée, utilisez les méthodes pop_front et pop_back:

LNK.pop_back ();
LNK.pop_front ();
println!(":? ", lnk);

La sortie est comme indiqué:

[1, 2, 3, 4, 5] // avant
[2, 3, 4] // après

Collections de cartes

La deuxième catégorie de collections de rouille dans les cartes, et celles-ci comprennent:

1. Hashmap
2. Btreemap

Hashmap

Un hashmap vous permet de stocker la cartographie des paires de valeurs clés. Il utilise une fonction de hachage pour déterminer comment les touches et les valeurs sont stockées en mémoire. Ils sont très utiles lorsque vous avez besoin de stocker des valeurs connexes. Il utilise une clé au lieu d'un index pour récupérer les valeurs.

Pour créer un nouveau hashmap, utilisez la syntaxe suivante:

Utilisez STD :: Collections :: Hashmap;
Laissez mut map = hashmap :: new ();

Pour insérer des paires de valeurs de clé sur un hashmap, utilisez la méthode d'insertion suivante:

carte.insérer (0, "angulaire");
carte.insérer (1, "réagir");
carte.insérer (3, "Mithril");
carte.insérer (4, "Vue");

Pour imprimer un hashmap, utilisez ce qui suit:

println!(":?", carte);

Cela devrait revenir comme indiqué ci-dessous:

1: "React", 2: "Svelte", 3: "Mithril", 4: "Vue", 0: "Angular"

Gardez à l'esprit que la clé et la valeur peuvent être n'importe quel type pris en charge.

Pour supprimer les éléments d'un hashmap, utilisez la méthode retire () comme suit:

carte.retirer (1);

Btreemap

Vous remarquez qu'un hashmap n'est pas trié. Si vous cherchez une carte triée, utilisez le btreemap. Chaque élément du btreemap est stocké dans son propre nœud alloué au tas.

Pour créer un nouveau btreemap, utilisez ce qui suit:

Utilisez STD :: Collections :: btreemap;
Laissez mut btree = btreemap :: new ();

Pour ajouter des éléments, utilisez la méthode d'insertion suivante.

btree.insert ("key", "valeur");

Pour supprimer un élément, utilisez la méthode de suppression comme:

btree.supprimer ("clé");

Définir les collections

La prochaine catégorie de collections de rouille est des ensembles. Ces types sont dérivés de la théorie des ensembles et incluent:

1. Hashsets
2. Btreeset

Hashsets

Un hashset est étroitement similaire à un hashmap. Cela signifie qu'il s'agit d'une forme définie d'un hashmap et ne permet pas de valeurs en double.

Pour créer un nouveau HashSet, utilisez la syntaxe suivante:

Utilisez STD :: Collections :: HashSet;
Let Mut set = hashset :: new ();

Utilisez les méthodes d'insertion et de suppression pour ajouter et supprimer les éléments d'un hashmap, respectivement.

ensemble.insérer ("a");
ensemble.retirer ("a");

Btreeset

Ceci est une mise en œuvre définie d'un btreemap. Nous pouvons créer un nouveau btreeset comme indiqué ci-dessous:

Utilisez Std :: Collections :: Btreeset;
Laissez mut set = btreeset :: new ();

Insérez et supprimez les éléments indiqués ci-dessous:

ensemble.insérer ("a");
ensemble.retirer ("a");

Collections divers

Il n'y a qu'un seul type dans les collections divers.

1. Binaire

Binaire

Le tas binaire vous permet de mettre en œuvre un ample arbre binaire. Vous pouvez créer un nouveau tas binaire comme indiqué ci-dessous:

Utilisez Std :: Collections :: BinaryHeap;
Laissez mut tas = binaryheap :: new ();

Pour ajouter des éléments, utilisez la méthode push suivante:

tas.push ("item");

Pour supprimer une valeur, utilisez la méthode POP suivante:

tas.populaire();

La méthode POP supprime le plus grand élément d'un tas.

Conclusion

Ce guide couvre les structures de données populaires et utiles et leurs opérations de base dans le langage de programmation Rust. De plus, nous avons discuté en détail des quatre principales catégories des collections de rouille, telles que les séquences, les cartes, les ensembles et les divers. Nous espérons que vous avez trouvé cet article utile. Vérifiez les autres articles sur les indices Linux pour plus de conseils et d'informations.