Come utilizzare le strutture di dati in ruggine

Rust utilizza la libreria di raccolte per supportare e implementare diverse strutture di dati comuni. Una raccolta si riferisce a una raccolta di uno o più valori memorizzati nella memoria heap. Ciò significa che la dimensione della raccolta non deve essere nota prima della compilation.

Le raccolte sono molto utili quando implementano l'archiviazione dei dati flessibili e generici. La maggior parte delle collezioni può ridursi o crescere nel programma.

Esploriamo varie strutture di dati nel linguaggio di programmazione Rust e come eseguire le operazioni di base.

Qui, abbiamo le quattro principali categorie per le collezioni di ruggine:

1. Sequenze
2. Mappe
3. Imposta
4. Misc

Discutiamo in dettaglio ogni categoria.

Collezioni di sequenze

Qui discuteremo i tre tipi di raccolte di sequenze in ruggine:

1. Vec
2. Vecdeque
3. Lista collegata

Vec

Un vec o un vettore è un array contiguo crescente che memorizza i valori in un elenco, uno dopo l'altro nella memoria.

Per creare un nuovo vettore vuoto, utilizzare il nuovo metodo come mostrato di seguito:

let mut vec = vec :: new ();

Quindi, è possibile aggiungere elementi al vettore usando il metodo push:

Vec.Push (1);
Vec.Push (2);

Per stampare un vettore, utilizzare il tratto di debug come previsto di seguito:

println!(":? ", vec);

Rimuovere l'elemento in un vettore usando il metodo Rimuovi e l'indice dell'elemento da rimuovere, come mostrato di seguito:

Vec.rimuovere (0); // Rimuovi l'elemento all'indice 0
println!(":? ", vec);

Vecdeque

Un vettore vecdeque o a doppia estremità è un tampone ad anello coltivabile non contiguo. Possiamo creare un nuovo buffer vuoto usando il nuovo metodo come previsto di seguito:

Usa std :: collezioni :: vecdeque;
let mut deque = vecdeque :: new ();

VECDEque utilizza metodi push_front () e push_back () per aggiungere elementi alla parte anteriore o posteriore del deque:

Deque.push_front (1);
Deque.push_front (2);
Deque.push_front (3);
// respingere
Deque.push_back (4);
Deque.push_back (5);

Per stampare gli elementi del vecdeque, utilizzare il tratto di debug:

Println!(":? ", deque);

Per rimuovere gli elementi da un vecdeque, utilizzare i metodi pop_front () e pop_back () per rimuovere rispettivamente un elemento dalla parte anteriore e posteriore del deque.

Di seguito è riportato il seguente esempio:

Deque.pop_back ();
Deque.pop_front ();
println!(":? ", deque);

Questo dovrebbe tornare come mostrato di seguito:

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

Lista collegata

Questo è un elenco doppiamente collegato ai nodi di proprietà. È utile quando è necessario un vettore o un deque di dimensioni sconosciute.

Per creare una nuova lista Linked vuota, utilizzare quanto segue:

Usa std :: Collections :: LinkedList;
let mut lnk = LinkedList :: new ();

Usiamo i metodi push_front () e push_back () per aggiungere elementi alla parte anteriore e posteriore di un elenco collegato, rispettivamente.

Per esempio:

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'esempio precedente dovrebbe tornare come segue:

[1, 2, 3, 4, 5]

Per rimuovere gli elementi da un elenco collegato, utilizzare i metodi pop_front e pop_back:

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

L'output è come mostrato:

[1, 2, 3, 4, 5] // prima
[2, 3, 4] // dopo

Collezioni di mappe

La seconda categoria di raccolte di ruggine nelle mappe e queste includono:

1. Hashmap
2. Btreemap

Hashmap

Un hashmap consente di archiviare la mappatura delle coppie di valore chiave. Utilizza una funzione di hashing per determinare come i tasti e i valori sono archiviati in memoria. Sono molto utili quando è necessario archiviare valori correlati. Utilizza una chiave anziché un indice per recuperare i valori.

Per creare un nuovo hashmap, utilizzare la seguente sintassi:

Usa std :: collezioni :: hashmap;
let mut map = hashmap :: new ();

Per inserire coppie di valore chiave su un hashmap, utilizzare il seguente metodo di insert:

carta geografica.inserire (0, "angolare");
carta geografica.inserire (1, "react");
carta geografica.inserire (3, "mithril");
carta geografica.inserire (4, "vue");

Per stampare un hashmap, utilizzare quanto segue:

println!(":?", carta geografica);

Questo dovrebbe tornare come mostrato di seguito:

1: "react", 2: "svelte", 3: "mithril", 4: "vue", 0: "angolare"

Tieni presente che la chiave e il valore possono essere qualsiasi tipo supportato.

Per eliminare gli elementi da un hashmap, utilizzare il metodo Rimovi () come segue:

carta geografica.rimuovere (1);

Btreemap

Noti che un hashmap non è risolto. Se stai cercando una mappa ordinata, usa il btreemap. Ogni elemento nel btreemap è memorizzato nel proprio nodo allocato.

Per creare un nuovo btreemap, utilizzare quanto segue:

Usa std :: collezioni :: btreemap;
let mut btree = btreemap :: new ();

Per aggiungere elementi, utilizzare il seguente metodo di insert.

btree.inserire ("chiave", "valore");

Per eliminare un elemento, utilizzare il metodo Rimuovi come:

btree.rimuovere ("chiave");

Imposta collezioni

La prossima categoria di raccolte di ruggine sono set. Questi tipi derivano dalla teoria degli insiemi e includono:

1. Hashset
2. Btreeset

Hashset

Un hashset è strettamente simile a un hashmap. Ciò significa che è una forma impostata di un hashmap e non consente valori duplicati.

Per creare un nuovo hashset, utilizzare la seguente sintassi:

Usa std :: collezioni :: hashset;
let mut set = hashset :: new ();

Utilizzare i metodi Insert and Reyt per aggiungere ed eliminare gli elementi da un hashmap, rispettivamente.

impostato.inserire ("a");
impostato.rimuovere ("a");

Btreeset

Questa è un'implementazione impostata di un btreemap. Possiamo creare un nuovo btreeset come mostrato di seguito:

Usa std :: Collections :: btreeset;
let mut set = btreeset :: new ();

Inserire e rimuovere gli elementi come previsto di seguito:

impostato.inserire ("a");
impostato.rimuovere ("a");

Collezioni di misure

C'è solo un tipo nelle collezioni di misure.

1. Binaryheap

Binaryheap

Binary Heap ti consente di implementare un ampio albero binario. È possibile creare un nuovo heap binario come previsto di seguito:

Usa std :: Collezioni :: BinaryHeap;
let mut heap = binaryheap :: new ();

Per aggiungere elementi, utilizzare il seguente metodo push:

mucchio.push ("oggetto");

Per rimuovere un valore, utilizzare il seguente metodo pop:

mucchio.pop();

Il metodo pop rimuove l'oggetto più grande in un mucchio.

Conclusione

Questa guida copre le strutture di dati popolari e utili e le loro operazioni di base nel linguaggio di programmazione Rust. Inoltre, abbiamo discusso in dettaglio le quattro principali categorie delle collezioni di ruggine, come sequenze, mappe, set e misc. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.