Como usar estruturas de dados em ferrugem

Rust usa a biblioteca de coleções para apoiar e implementar várias estruturas de dados comuns. Uma coleção refere -se a uma coleção de um ou mais valores armazenados na memória da heap. Isso significa que o tamanho da coleção não precisa ser conhecido antes da compilação.

As coleções são muito úteis ao implementar o armazenamento de dados flexíveis e genéricos. A maioria das coleções pode encolher ou crescer no programa.

Vamos explorar várias estruturas de dados na linguagem de programação de ferrugem e como executar as operações básicas.

Aqui, temos as quatro principais categorias para as coleções de ferrugem:

1. Sequências
2. Mapas
3. Conjuntos
4. Misc

Vamos discutir cada categoria em detalhes.

Coleções de sequência

Aqui, discutiremos os três tipos de coleções de sequência em Rust:

1. VEC
2. Vecdeque
3. LinkedList

VEC

Um VEC ou vetor é uma matriz cultivável contígua que armazena valores em uma lista, um após o outro na memória.

Para criar um novo vetor vazio, use o novo método, como mostrado abaixo:

Seja mut vec = vec :: new ();

Em seguida, você pode adicionar elementos ao vetor usando o método push:

VEC.push (1);
VEC.push (2);

Para imprimir um vetor, use o traço de depuração, conforme fornecido abaixo:

println!(":? ", vec);

Remova o elemento em um vetor usando o método Remover e o índice do elemento a ser removido, como mostrado abaixo:

VEC.remover (0); // Remova o elemento no índice 0
println!(":? ", vec);

Vecdeque

Um vetor de vecdeque ou de ponta dupla é um tampão de anel cultivável não contíguo. Podemos criar um novo buffer vazio usando o novo método, conforme fornecido abaixo:

Use STD :: Coleções :: Vecdeque;
Deixe mut deque = vecdeque :: new ();

Os métodos Vecdeque usa push_front () e push_back () para adicionar elementos à frente ou traseira do deque:

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

Para imprimir os elementos do Vecdeque, use o traço de depuração:

Println!(":? ", deque);

Para remover os elementos de um Vecdeque, use os métodos Pop_front () e Pop_back () para remover um elemento da frente e de trás do deque, respectivamente.

O exemplo a seguir é fornecido abaixo:

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

Isso deve retornar como mostrado abaixo:

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

LinkedList

Esta é uma lista duplamente vinculada com nós próprios. É útil quando você precisa de um vetor ou deque de tamanho desconhecido.

Para criar uma nova lista LinkedList vazia, use o seguinte:

Use STD :: Coleções :: LinkedList;
Seja Mut Lnk = LinkedList :: new ();

Usamos os métodos push_front () e push_back () para adicionar elementos à frente e traseira de uma lista vinculada, respectivamente.

Por exemplo:

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

O exemplo anterior deve retornar da seguinte maneira:

[1, 2, 3, 4, 5]

Para remover elementos de uma lista vinculada, use os métodos Pop_front e Pop_back:

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

A saída é como mostrado:

[1, 2, 3, 4, 5] // antes de
[2, 3, 4] // depois

Coleções de mapas

A segunda categoria de coleções de ferrugem nos mapas, e estes incluem:

1. Hashmap
2. BTTEEMAP

Hashmap

Um hashmap permite que você armazene o mapeamento de pares de valores-chave. Ele usa uma função de hash para determinar como as chaves e os valores são armazenados na memória. Eles são muito úteis quando você precisa armazenar valores relacionados. Ele usa uma chave em vez de um índice para recuperar valores.

Para criar um novo hashmap, use a seguinte sintaxe:

Use STD :: Coleções :: Hashmap;
Deixe Mut mapa = hashmap :: new ();

Para inserir pares de valor-chave em um hashmap, use o seguinte método de inserção:

mapa.inserir (0, "angular");
mapa.inserir (1, "react");
mapa.inserir (3, "mithril");
mapa.inserir (4, "vue");

Para imprimir um hashmap, use o seguinte:

println!(":? ", mapa);

Isso deve retornar como mostrado abaixo:

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

Lembre -se de que a chave e o valor podem ser qualquer tipo suportado.

Para excluir elementos de um hashmap, use o método remove () da seguinte forma:

mapa.remover (1);

BTTEEMAP

Você percebe que um hashmap não é classificado. Se você está procurando um mapa classificado, use o BTTEEMAP. Cada elemento no breeMap é armazenado em seu próprio nó alocado por heap.

Para criar um novo breeMap, use o seguinte:

use std :: coletes :: btreemap;
Deixe mut btree = btreemap :: new ();

Para adicionar elementos, use o seguinte método de inserção.

btree.inserir ("chave", "valor");

Para excluir um elemento, use o método Remover como:

btree.remover ("chave");

Definir coleções

A próxima categoria de coleções de ferrugem é o conjunto. Esses tipos são derivados da teoria dos conjuntos e incluem:

1. Hashsets
2. Btreeset

Hashsets

Um hashset é intimamente semelhante a um hashmap. Isso significa que é uma forma definida de um hashmap e não permite valores duplicados.

Para criar um novo hashset, use a seguinte sintaxe:

Use STD :: Coleções :: HashSet;
Deixe mut set = hashSet :: new ();

Use a inserção e remova os métodos para adicionar e excluir elementos de um hashmap, respectivamente.

definir.inserir ("a");
definir.remover ("a");

Btreeset

Esta é uma implementação definida de um breeMap. Podemos criar um novo btreeset, como mostrado abaixo:

use std :: coletes :: btreeset;
Deixe mut set = btreeset :: new ();

Insira e remova os elementos conforme fornecido abaixo:

definir.inserir ("a");
definir.remover ("a");

Coleções misc

Existe apenas um tipo nas coleções misc.

1. BinaryHeap

BinaryHeap

Heap binário permite que você implemente uma ampla árvore binária. Você pode criar uma nova pilha binária, conforme fornecido abaixo:

Use STD :: Coleções :: BinaryHeap;
Seja mut heap = binaryheap :: new ();

Para adicionar elementos, use o seguinte método push:

pilha.push ("item");

Para remover um valor, use o seguinte método pop:

pilha.pop ();

O método pop remove o melhor item em uma pilha.

Conclusão

Este guia abrange as estruturas de dados populares e úteis e suas operações básicas na linguagem de programação de ferrugem. Além disso, discutimos em detalhes as quatro principais categorias das coleções de ferrugem, como sequências, mapas, conjuntos e Misc. Esperamos que você tenha achado este artigo útil. Verifique os outros artigos de dica do Linux para obter mais dicas e informações.