¿Qué es la cola en Golang?

Que Es La Cola En Golang



Go es un lenguaje de programación popular elogiado por su eficiencia, facilidad de uso y adaptabilidad. Con un amplio conjunto de herramientas y bibliotecas, Go proporciona a los desarrolladores los recursos necesarios para crear aplicaciones de software potentes y eficientes. Aunque Go no tiene cruz en su biblioteca estándar como estructura de datos, se pueden implementar utilizando varios métodos. Hablaremos del concepto de cruz y cómo implementarlos en este tutorial.

¿Qué es una cola?

Cruz son estructuras de datos que se utilizan para almacenar y recuperar elementos en un orden predeterminado. Es una estructura de datos lineal que se asemeja a una pila y se adhiere a la FIFO (primero en entrar, primero en salir) regla. Puede compararse con una lista de espera o una línea en la que se atiende primero a la primera persona que llega. Los componentes existentes se dejan caer desde el frente del cola , y se agregan nuevos elementos en la parte posterior.

Implementación de una cola en Golang

La implementación de un cola en Go es simple y eficiente y se puede implementar usando los siguientes cuatro métodos.







1: rebanadas

En Go, un rebanada es una matriz dinámica que puede cambiar de tamaño. Para implementar un cola usando un rebanada , podemos añadir elementos a la parte posterior de la rebanada utilizando la función incorporada de agregar y eliminar elementos de la parte frontal de la rebanada usando rebanar.



Este enfoque es fácil de construir y ofrece un buen rendimiento para agregar y dividir operaciones gracias a las divisiones integradas de Go. Sin embargo, el método de división, que incluye copiar elementos a una nueva matriz subyacente, puede volverse ineficiente si el cola se expande y requiere operaciones repetidas de eliminación de cola.



El siguiente código define el cola implementación usando un segmento en Go.





paquete principal

importar 'fmt'

función principal ( ) {

cola := hacer ( [ ] interfaz { } , 0 )

cola = adjuntar ( cola , 'inglés' )

cola = adjuntar ( cola , 'urdu' )

cola = adjuntar ( cola , 'matemáticas' )

    si solo ( cola ) > 0 {

artículo := cola [ 0 ]

cola = cola [ 1 : ]

fmt. Imprimir ( artículo )

    }

    si solo ( cola ) == 0 {

fmt. Imprimir ( 'La cola está vacía' )

    } demás {

fmt. Imprimir ( cola )

    }

}

El código de Go anterior usa un segmento para construir un cola estructura de datos. El adjuntar() La función se utiliza para poner en cola elementos en el cola slice, y se usa una operación de slice que elimina el elemento inicial para sacarlos de la cola. Con fmt.Println() , se imprime el elemento fuera de la cola. A continuación, el código utiliza el solo() función para determinar si la cola está vacía, y si lo está, escribe ' Cola está vacío” utilizando la función fmt.Println().

Producción



2: Listas enlazadas

Los nodos que llevan un valor y un puntero al siguiente nodo en la lista forman una lista enlazada. Con dos punteros, uno apuntando al frente (cabeza) de la lista y el otro apuntando a la parte trasera (cola), podemos implementar un cola utilizando una lista enlazada. Eliminar un elemento de la cola (desencolar) implica eliminar el nodo al principio de la lista, mientras que agregar un elemento a la cola (encolar) implica agregar un nuevo nodo al final de la lista.

Este método permite operaciones eficientes de encolado y desencolado porque solo es necesario cambiar los punteros de cabeza y cola, a diferencia de la solución basada en cortes en la que sería necesario copiar los elementos.

Use una lista enlazada para implementar un cola utilizando el código proporcionado a continuación:

paquete principal

importar 'fmt'

tipo de nodo estructura {

interfaz de valor { }

próximo * Nodo

}

tipo cola estructura {

cabeza * Nodo

cola * Nodo

}

función principal ( ) {

cola := & Cola { cabeza : nulo , cola : nulo }

nuevoNodo := & Nodo { valor : 'inglés' , próximo : nulo }

cola. cola = nuevoNodo

cola. cabeza = nuevoNodo

nuevoNodo = & Nodo { valor : 'urdu' , próximo : nulo }

cola. cola . próximo = nuevoNodo

cola. cola = nuevoNodo

nuevoNodo = & Nodo { valor : 'matemáticas' , próximo : nulo }

cola. cola . próximo = nuevoNodo

cola. cola = nuevoNodo

    si cola. cabeza != nulo {

artículo := cola. cabeza . valor

cola. cabeza = cola. cabeza . próximo

fmt. Imprimir ( artículo )

    }

    si cola. cabeza == nulo {

fmt. Imprimir ( 'La cola está vacía' )

    }

}

La estructura Node representa cada elemento en la cola y contiene dos campos: un campo de valor para almacenar el valor del elemento y el siguiente campo para señalar el siguiente elemento en la cola. La estructura Queue utiliza las propiedades head y tail para realizar un seguimiento de la parte delantera y trasera de la cola, respectivamente. El cruz el primer elemento se indica con la propiedad head, mientras que el último elemento se indica con la propiedad tail.

Los parámetros de cabeza y cola se establecen inicialmente en nulo cuando un nuevo cola se establece en la función main(). Los punteros de cabeza y cola se actualizan para agregar tres nodos al cola con los valores 'inglés', 'urdu', y 'matemáticas'. El 'inglés' el artículo es entonces 'desencolado' (retirado) de la parte delantera del cola mostrando su valor y avanzando el puntero principal al siguiente nodo en el cola . Después de eliminar la cola, si el encabezado se vuelve nulo, significa que la cola está vacía y aparece el mensaje ' Cola está vacío” se imprime.

Producción

3: Estructuras

En Go, puede crear una estructura de datos personalizada denominada estructura para representar un cola . Este estructura puede tener campos para almacenar el cola Elementos y métodos para agregar y eliminar elementos, verificar si la cola está vacía y obtener el tamaño actual de la cola.

Esta forma de crear un cola in Go ofrece una implementación conveniente y encapsulada con métodos fáciles de usar que se pueden expandir y personalizar con más funciones. Es un enfoque flexible que permite realizar cambios en la implementación o agregar nuevas capacidades cuando sea necesario.

Crear una costumbre estructura con métodos implica escribir código adicional en comparación con las otras dos formas, lo que puede aumentar la complejidad. Sin embargo, también proporciona más flexibilidad y control sobre la implementación del cola .

El siguiente ejemplo muestra la creación de una estructura de datos para representar un cola en Ir.

paquete principal

importar 'fmt'

tipo cola estructura {
elementos [ ] interfaz { }
}

función ( q * Cola ) poner en cola ( interfaz de elemento { } ) {
q. elementos = adjuntar ( q. elementos , artículo )
}

función ( q * Cola ) Quitar de la cola ( ) interfaz { } {
    si solo ( q. elementos ) == 0 {
        devolver nulo
    }
artículo := q. elementos [ 0 ]
q. elementos = q. elementos [ 1 : ]
    devolver artículo
}

función ( q * Cola ) Esta vacio ( ) bool {
    devolver solo ( q. elementos ) == 0
}

función ( q * Cola ) Tamaño ( ) En t {
    devolver solo ( q. elementos )
}


función principal ( ) {

cola := & Cola { elementos : hacer ( [ ] interfaz { } , 0 ) }

cola. poner en cola ( 'inglés' )
cola. poner en cola ( 'urdu' )
cola. poner en cola ( 'matemáticas' )

artículo := cola. Quitar de la cola ( )
fmt. Imprimir ( artículo )
    si cola. Esta vacio ( ) {
fmt. Imprimir ( 'La cola está vacía' )
    }

tamaño := cola. Tamaño ( )
fmt. Imprimir ( 'Tamaño de la cola:' , tamaño )
}

En el código anterior, se agrega un elemento a la porción del elemento a través de la Poner en cola() método, que lo mueve al final del cola . Siguiendo el Primero en entrar, primero en salir (FIFO) principio, el Quitar de la cola() método toma un elemento de la parte delantera de la cola y lo devuelve. La longitud de la porción del artículo se verifica como parte de la Esta vacio() verificación del método para ver si el cola esta vacio. Al devolver la longitud del segmento de elementos, el Tamaño() método devuelve el actual cruz tamaño.

La función main() utiliza el Estructura de cola para crear un nuevo cola , agregarle elementos, eliminar elementos de él, determinar si el cola está vacío y calcula su tamaño.

Producción

4: Canales

En Go, el tipo de canal integrado se puede utilizar para implementar un cola estructura de datos. El canal se puede crear con un tamaño de búfer para limitar el número de elementos que se pueden poner en cola en un momento dado. Para agregar un elemento a la cola , se puede enviar al canal usando el <- operador, mientras que para eliminar un elemento de la cola, se puede recibir desde el canal utilizando el mismo operador.

Este enfoque puede ser muy útil en situaciones en las que el acceso simultáneo a la cola es necesario, ya que los canales son intrínsecamente seguros para el uso concurrente.

Es crucial recordar que los canales Go están escritos. Esto significa que solo puede enviar valores de un tipo específico a través de un canal y solo puede recibir valores de ese mismo tipo del canal.

Esta es una ilustración de cómo usar un canal para construir un cola estructura de datos en Go.

paquete principal

importar (
    'fmt'
    'tiempo'
)

tipo cola estructura {
elementos interfaz de canal { }
}

funciónNuevaCola ( ) * Cola {


q := & Cola {

elementos : hacer ( interfaz de canales { } ) ,
    }
ir q. elementos de proceso ( )
    devolver q
}

función ( q * Cola ) elementos de proceso ( ) {
    para artículo := rango q. elementos {
        si artículo == 'inglés' {
fmt. Imprimir ( 'Desencolado:' , artículo )
        }
    }
}


función ( q * Cola ) poner en cola ( interfaz de elemento { } ) {

q. elementos <- artículo

}

función principal ( ) {
cola := Nueva cola ( )

cola. poner en cola ( 'inglés' )
cola. poner en cola ( 'urdu' )
cola. poner en cola ( 'matemáticas' )

    tiempo . Dormir ( 2 * tiempo . Segundo )
}

El código anterior crea un Estructura de cola con un solo campo elementos que es un canal de interfaz{} tipo. El NuevaCola() función crea una nueva instancia de la Cola e inicializa su 'elementos' campo con un nuevo canal sin búfer. También inicia una nueva gorutina para procesar los elementos agregados a la cola usando el elementos de proceso () función. El elementos de proceso () La función comprueba si el artículo recibido es igual a 'inglés' e imprime un mensaje en la consola solo para ese elemento. El Poner en cola() La función se utiliza para agregar nuevos elementos a la cola.

Producción

Conclusión

La cola es una estructura de datos esencial en Go que se utiliza para almacenar y recuperar elementos en un orden específico. La implementación de un cola en Go es seguro para subprocesos, lo que los convierte en una opción ideal para implementar la concurrencia en los programas. Se puede implementar utilizando segmentos, listas enlazadas, estructuras y canales. Los detalles completos ya se proporcionan en las pautas dadas anteriormente.