Cómo usar estructuras de datos en óxido

Rust usa la biblioteca de colecciones para apoyar e implementar varias estructuras de datos comunes. Una colección se refiere a una colección de uno o más valores almacenados en la memoria del montón. Esto significa que el tamaño de la colección no necesita ser conocido antes de la compilación.

Las colecciones son muy útiles cuando se implementan almacenamiento de datos flexible y genérico. La mayoría de las colecciones pueden reducirse o crecer en el programa.

Explore varias estructuras de datos en el lenguaje de programación de óxido y cómo realizar las operaciones básicas.

Aquí, tenemos las cuatro categorías principales para las colecciones de óxido:

1. Secuencias
2. Mapas
3. Sets
4. Maga

Discutamos cada categoría en detalle.

Colecciones de secuencia

Aquí, discutiremos los tres tipos de colecciones de secuencias en Rust:

1. VEC
2. Vecdeque
3. Lista enlazada

VEC

Un vec o vector es una matriz crecible contigua que almacena valores en una lista, una tras otra en la memoria.

Para crear un nuevo vector vacío, use el nuevo método como se muestra a continuación:

Let Mut vec = vec :: new ();

Luego, puede agregar elementos al vector utilizando el método PUSH:

VEC.empuje (1);
VEC.empuje (2);

Para imprimir un vector, use el rasgo de depuración según lo dispuesto a continuación:

println!(":? ", vec);

Retire el elemento en un vector usando el método eliminar y el índice del elemento para eliminar, como se muestra a continuación:

VEC.eliminar (0); // eliminar el elemento en el índice 0
println!(":? ", vec);

Vecdeque

Un vector vecdeque o un vector doble es un tampón de anillo crecible no contiguo. Podemos crear un nuevo búfer vacío utilizando el nuevo método que se proporciona a continuación:

usar std :: colecciones :: vecdeque;
Let Mut Deque = vecdeque :: new ();

El Vecdeque usa métodos push_front () y push_back () para agregar elementos a la parte delantera o posterior del deque:

Deparar.push_front (1);
deparar.push_front (2);
deparar.push_front (3);
// hacer retroceder
deparar.push_back (4);
deparar.push_back (5);

Para imprimir los elementos del Vecdeque, use el rasgo de depuración:

Println!(":? ", deque);

Para eliminar elementos de un vecdeque, use los métodos pop_front () y pop_back () para eliminar un elemento de la parte delantera y trasera del deque respectivamente.

El siguiente ejemplo se proporciona a continuación:

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

Esto debería volver como se muestra a continuación:

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

Lista enlazada

Esta es una lista doblemente vinculada con nodos propios. Es útil cuando necesita un vector o un deque de tamaño desconocido.

Para crear una nueva LinkedList vacía, use lo siguiente:

usar std :: colecciones :: LinkedList;
Let Mut lnk = LinkedList :: new ();

Usamos los métodos push_front () y push_back () para agregar elementos al frente y la parte posterior de una lista vinculada, respectivamente.

Por ejemplo:

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

El ejemplo anterior debería volver de la siguiente manera:

[1, 2, 3, 4, 5]

Para eliminar elementos de una lista vinculada, use los métodos POP_FRONT y POP_BACK:

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

La salida es como se muestra:

[1, 2, 3, 4, 5] // antes
[2, 3, 4] // después

Colecciones de mapas

La segunda categoría de colecciones de óxido en mapas, y estos incluyen:

1. Mapache
2. Btreemap

Mapache

Un hashmap le permite almacenar el mapeo de pares de valores clave. Utiliza una función de hash para determinar cómo se almacenan las teclas y los valores en la memoria. Son muy útiles cuando necesitas almacenar valores relacionados. Utiliza una clave en lugar de un índice para recuperar valores.

Para crear un nuevo hashmap, use la siguiente sintaxis:

usar std :: colecciones :: hashmap;
Let Mut map = hashmap :: new ();

Para insertar pares de valor clave en un hashmap, use el siguiente método de inserción:

mapa.insertar (0, "angular");
mapa.insertar (1, "reaccionar");
mapa.insertar (3, "mithril");
mapa.insertar (4, "vue");

Para imprimir un hashmap, use lo siguiente:

println!(":?", mapa);

Esto debería volver como se muestra a continuación:

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

Tenga en cuenta que la clave y el valor pueden ser cualquier tipo compatible.

Para eliminar elementos de un hashmap, use el método remove () de la siguiente manera:

mapa.eliminar (1);

Btreemap

Notas que un hashmap no está ordenado. Si está buscando un mapa ordenado, use el btreemap. Cada elemento en el btreemap se almacena en su propio nodo asignado por montón.

Para crear un nuevo BTreeMap, use lo siguiente:

use std :: colecciones :: btreemap;
Let Mut btree = btreemap :: new ();

Para agregar elementos, use el siguiente método de inserción.

btree.insertar ("clave", "valor");

Para eliminar un elemento, use el método eliminar como:

btree.eliminar ("clave");

Establecer colecciones

La siguiente categoría de colecciones de óxido es. Estos tipos se derivan de la teoría del conjunto e incluyen:

1. Hassets
2. Btreeset

Hassets

Un hashset es muy similar a un hashmap. Esto significa que es una forma establecida de un hashmap y no permite valores duplicados.

Para crear un nuevo hashset, use la siguiente sintaxis:

usar std :: colecciones :: hashset;
Let Mut set = hashset :: new ();

Use el inserto y elimine los métodos para agregar y eliminar elementos de un hashmap, respectivamente.

colocar.insertar ("a");
colocar.eliminar ("a");

Btreeset

Esta es una implementación establecida de un btreemap. Podemos crear un nuevo btreeset como se muestra a continuación:

usar std :: colecciones :: btreeset;
Let Mut set = btreeSet :: new ();

Inserte y elimine los elementos según lo dispuesto a continuación:

colocar.insertar ("a");
colocar.eliminar ("a");

Colecciones misceláneas

Solo hay un tipo en las colecciones misceláneas.

1. Binaryheap

Binaryheap

El montón binario le permite implementar un amplio árbol binario. Puede crear un nuevo montón binario como se proporciona a continuación:

usar std :: colecciones :: binaryheap;
Let Mut Heap = BinaryHeap :: New ();

Para agregar elementos, use el siguiente método de empuje:

montón.push ("elemento");

Para eliminar un valor, use el siguiente método POP:

montón.estallido();

El método POP elimina el mejor elemento en un montón.

Conclusión

Esta guía cubre las estructuras de datos populares y útiles y sus operaciones básicas en el lenguaje de programación de óxido. Además, discutimos en detalle las cuatro categorías principales de las colecciones de óxido, como secuencias, mapas, sets y misc. Esperamos que hayas encontrado este artículo útil. Consulte los otros artículos de Sugerencia de Linux para obtener más consejos e información.