So verwenden Sie Datenstrukturen in Rost

Rust verwendet die Sammlungsbibliothek, um mehrere gemeinsame Datenstrukturen zu unterstützen und zu implementieren. Eine Sammlung bezieht sich auf eine Sammlung von einem oder mehreren Werten, die im Heap -Speicher gespeichert sind. Dies bedeutet, dass die Sammelgröße vor der Zusammenstellung nicht bekannt sein muss.

Sammlungen sind sehr nützlich bei der Implementierung einer flexiblen und generischen Datenspeicherung. Die meisten Sammlungen können im Programm schrumpfen oder wachsen.

Erforschen wir verschiedene Datenstrukturen in der Rost -Programmiersprache und wie die Grundvorgänge ausführen.

Hier haben wir die vier Hauptkategorien für die Rust -Sammlungen:

1. Sequenzen
2. Karten
3. Sets
4. Miser

Lassen Sie uns jede Kategorie im Detail diskutieren.

Sequenzsammlungen

Hier werden wir die drei Arten von Sequenzsammlungen in Rost diskutieren:

1. Vec
2. Vecdeque
3. LinkedList

Vec

Ein VEC oder Vektor ist ein zusammenhängendes wachsbares Array, das Werte in einer Liste speichert, eine nacheinander im Speicher.

Verwenden Sie die neue Methode wie unten gezeigt, um einen neuen leeren Vektor zu erstellen:

lass mut vec = vec :: new ();

Anschließend können Sie dem Vektor mit der Push -Methode Elemente hinzufügen:

vec.Push (1);
vec.Push (2);

Verwenden Sie zum Drucken eines Vektors das Debug -Merkmal wie unten angegeben:

println!(":? ", vec);

Entfernen Sie das Element in einem Vektor mit der Entfernungsmethode und dem zu entfernenen Index des Elements, wie unten gezeigt:

Vec.entfernen (0); // Element am Index 0 entfernen
println!(":? ", vec);

Vecdeque

Ein Vecdeque oder ein doppeltender Vektor ist ein nicht verknüpfter Wachstumsringpuffer. Wir können einen neuen leeren Puffer mit der neuen Methode erstellen, wie unten angegeben:

Verwenden Sie STD :: Collections :: Vecdeque;
lass mut deque = vecdeque :: new ();

Die Vecdeque verwendet die Methoden PUSP_FRONT () und PUSPE_BACK (), um Elemente zur Vorder- oder Rückseite des Deque hinzuzufügen:

Deque.push_front (1);
Deque.push_front (2);
Deque.push_front (3);
// zurückschieben
Deque.push_back (4);
Deque.push_back (5);

Verwenden Sie das Debug -Merkmal, um die Elemente der Vecdeque zu drucken:

Println!(":? ", deque);

Um Elemente aus einem Vecdeque zu entfernen.

Das folgende Beispiel finden Sie unten:

Deque.Pop zurück();
Deque.pop_front ();
println!(":? ", deque);

Dies sollte wie unten gezeigt zurückkehren:

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

LinkedList

Dies ist eine doppelt verknüpfte Liste mit Besitzknoten. Es ist nützlich, wenn Sie einen Vektor oder eine Deque mit unbekannter Größe benötigen.

Verwenden Sie Folgendes, um eine neue leere LinkedList zu erstellen:

Verwenden Sie STD :: Collections :: LinkedList;
lass mut lnk = linkedList :: new ();

Wir verwenden die Methoden Push_Front () und Push_back (), um Elemente zur Vorder- und Rückseite einer verknüpften Liste hinzuzufügen.

Zum Beispiel:

lass 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);

Das vorherige Beispiel sollte wie folgt zurückkehren:

[1, 2, 3, 4, 5]

Um Elemente aus einer verknüpften Liste zu entfernen, verwenden Sie die Methoden POP_FRONT und POP_BACK:

lnk.Pop zurück();
lnk.pop_front ();
println!(":? ", lnk);

Der Ausgang ist wie gezeigt:

[1, 2, 3, 4, 5] // vor
[2, 3, 4] // nach

Kartensammlungen

Die zweite Kategorie von Rostsammlungen in Karten, darunter:

1. Hashmap
2. BTREEMAP

Hashmap

Mit einem HashMap können Sie die Zuordnung von Schlüsselwertpaaren speichern. Es verwendet eine Hashing -Funktion, um zu bestimmen, wie die Schlüssel und Werte im Speicher gespeichert werden. Sie sind sehr nützlich, wenn Sie verwandte Werte speichern müssen. Es verwendet einen Schlüssel anstelle eines Index, um Werte abzurufen.

Verwenden Sie die folgende Syntax, um eine neue HashMap zu erstellen:

Verwenden Sie STD :: Collections :: HashMap;
mut map = HashMap :: new ();

Verwenden Sie die folgende Einfügungsmethode, um Schlüsselwertpaare in ein HashMap einzulegen:

Karte.Insert (0, "Angular");
Karte.Insert (1, "reagieren");
Karte.Insert (3, "Mithril");
Karte.Insert (4, "Vue");

Verwenden Sie Folgendes, um eine Hashmap zu drucken:

println!(":?", Karte);

Dies sollte wie unten gezeigt zurückkehren:

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

Denken Sie daran, dass der Schlüssel und der Wert jeder unterstützte Typ sein können.

Um Elemente aus einem HashMap zu löschen, verwenden Sie die Methode von REME () wie folgt:

Karte.entfernen (1);

BTREEMAP

Sie bemerken, dass eine Hashmap nicht sortiert ist. Wenn Sie nach einer sortierten Karte suchen, verwenden Sie die BTREEMAP. Jedes Element in der BTREEMAP wird im eigenen Haufen zugeteilt.

Verwenden Sie Folgendes, um eine neue BTREEMAP zu erstellen:

Verwenden Sie STD :: Collections :: BTreemap;
lass mut btree = bTreemap :: new ();

Verwenden Sie zum Hinzufügen von Elementen die folgende Einfügungsmethode.

btree.Insert ("Schlüssel", "Wert");

Verwenden Sie zum Löschen eines Elements die Methode entfernen unter:

btree.entfernen ("Schlüssel");

Kollektionen festlegen

Die nächste Kategorie von Rostsammlungen sind Sets. Diese Typen stammen aus der festgelegten Theorie und umfassen:

1. Hashsets
2. Breeset

Hashsets

Ein Hashset ist einem HashMap sehr ähnlich. Dies bedeutet, dass es sich um eine festgelegte Form eines Hashmaps handelt und keine doppelten Werte zulässt.

Verwenden Sie die folgende Syntax, um ein neues Hashset zu erstellen:

Verwenden Sie STD :: Collections :: Hashset;
lass mut set = Hashset :: new ();

Verwenden Sie die Methoden einfügen und entfernen, um Elemente aus einem HashMap hinzuzufügen und zu löschen.

Satz.Insert ("a");
Satz.entfernen ("a");

Breeset

Dies ist eine festgelegte Implementierung eines BTREEMAP. Wir können wie unten gezeigt einen neuen Breeset erstellen:

Verwenden Sie STD :: Collections :: Breeset;
lass mut set = bTreeset :: new ();

Einlegen und entfernen Sie Elemente wie unten angegeben:

Satz.Insert ("a");
Satz.entfernen ("a");

MISC -Sammlungen

In den MISC -Sammlungen enthält nur einen Typ.

1. Binaryheap

Binaryheap

Binärer Haufen ermöglicht es Ihnen, einen ausreichenden binären Baum zu implementieren. Sie können einen neuen binären Haufen erstellen, wie unten angegeben:

Verwenden Sie STD :: Sammlungen :: Binaryheap;
lass mut heap = binaryheap :: new ();

Um Elemente hinzuzufügen, verwenden Sie die folgende Push -Methode:

Haufen.push ("item");

Verwenden Sie die folgende POP -Methode, um einen Wert zu entfernen:

Haufen.Pop();

Die POP -Methode entfernt den größten Artikel in einem Haufen.

Abschluss

Dieser Leitfaden deckt die beliebten und nützlichen Datenstrukturen und ihre grundlegenden Operationen in der Rust -Programmiersprache ab. Darüber hinaus haben wir die vier Hauptkategorien der Rust -Sammlungen detailliert detailliert erörtert, z. B. Sequenzen, Karten, Sets und Misc. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Informationen finden Sie in den anderen Linux -Hinweisartikeln.