Introducción
Una cola es una colección de elementos, donde el primer elemento agregado a la lista debe ser el primer elemento que se eliminará a continuación. Entonces, a medida que se agregan artículos a la colección, crece en tamaño, es decir, aumenta en longitud. Siempre que se elimine un elemento, debe ser el primero en agregar. Si los elementos se eliminan continuamente, el siguiente que se elimina es el segundo elemento; el tercero se quita después, y así sucesivamente.
Una vez eliminado el primer elemento de la lista original, el segundo se convierte en el primer elemento. Una vez que se ha eliminado el segundo elemento, el tercero se convierte en el primer elemento y así sucesivamente.
Un buen ejemplo de la vida real de una cola es cuando las personas hacen fila para esperar un servicio o un buen servicio. La primera persona se sirve primero antes que la última. Sin embargo, la cola de la que se habla en este tutorial es la cola de software, tal como se diseñó en C ++.
FIFO
FIFO significa primero en entrar, primero en salir. Es otra forma de apreciar la cola. Esto significa que el primer elemento que ingresa a la lista es el primer elemento que se eliminará, siempre que se lleve a cabo la eliminación. El comienzo de la lista se llama encabezado o anverso; el final de la lista se llama al final o al final.
Operaciones esenciales
Una cola de software debe tener al menos las siguientes operaciones:
empujar
Esta operación agrega un nuevo elemento al final de la cola. Esta operación se llama oficialmente poner en cola.
cambio
Esta operación elimina el primer elemento de la cola y el segundo elemento se convierte en el nuevo primer elemento. Esta operación se llama oficialmente sacar de cola. Se llama pop en C ++.
Este artículo explica cómo utilizar la estructura de datos de cola de C ++. Debe conocer los punteros y referencias de C ++ para comprender el resto de este artículo.
Clase y objetos
Una clase es un conjunto de variables y funciones que trabajan juntas, donde las variables no tienen valores asignados. Cuando se asignan valores a las variables, la clase se convierte en un objeto. Diferentes valores dados a la misma clase dan como resultado diferentes objetos; es decir, diferentes objetos son de la misma clase con diferentes valores. Se dice que crear un objeto a partir de una clase es instanciar el objeto.
El nombre, cola, es una clase. Un objeto creado a partir de la clase de cola tiene un nombre elegido por el programador.
Se necesita una función que pertenezca a una clase para crear una instancia de un objeto de la clase. En C ++, esa función tiene el mismo nombre que el nombre de la clase. Los objetos creados (instanciados) a partir de la clase tienen diferentes nombres que les da el programador.
Crear un objeto de la clase significa construir el objeto; también significa instanciar.
Un programa C ++ que usa la clase de cola, comienza con las siguientes líneas en la parte superior del archivo:
#incluir#incluir
usando el espacio de nombres std;
La primera línea es para entrada / salida. La segunda línea es para permitir que el programa use todas las características de la clase de cola. La tercera línea permite que el programa use los nombres en el espacio de nombres estándar.
Sobrecargar una función
Cuando dos o más firmas de funciones diferentes tienen el mismo nombre, se dice que ese nombre está sobrecargado. Cuando se llama a una función, el número y tipo de argumentos determinan qué función se ejecuta realmente.
Construcción
cola<escribe>nombre()La siguiente declaración crea una instancia de una cola denominada que de tipo int.
cola<En t>que;La cola está vacía. La declaración comienza con la palabra reservada, cola seguida de paréntesis angulares con el tipo de datos. Entonces tienes el nombre del programador para la cola.
Construir con la lista de inicializadores
La siguiente definición muestra cómo crear una cola con una lista de inicializadores:
cola<flotador>que({1.1, 2.2, 3.3, 4.4});Destruyendo una cola
Para destruir una cola, simplemente déjela fuera de alcance.
Acceso al elemento de cola
empujar (valor)
Una cola es una lista de primero en entrar, primero en salir. Entonces, cada valor se agrega desde atrás. El siguiente segmento de código crea una cola vacía, después de la cual se agregan cinco valores flotantes desde atrás:
cola<flotador>que;que.empujar(1.1);
que.empujar(2.2);
que.empujar(3.3);
que.empujar(4.4);
que.empujar(5.5);
tamaño () const
Esto devuelve el número de elementos en la cola. El siguiente código ilustra:
cola<flotador>que;que.empujar(1.1);que.empujar(2.2);que.empujar(3.3);que.empujar(4.4);que.empujar(5.5);
costo<<que.Talla() << ' orte';
La salida es 5.
parte delantera()
Esto devuelve una referencia al primer elemento de la cola, sin eliminar el elemento. El resultado del siguiente código es 1.1.
cola<flotador>que;que.empujar(1.1);que.empujar(2.2);que.empujar(3.3);que.empujar(4.4);que.empujar(5.5);
costo<<que.parte delantera() << ' orte';
El elemento no se elimina de la cola.
frente () const
Cuando la construcción de la cola está precedida por const, se ejecuta la expresión front () const en lugar de front (). Se utiliza en el siguiente código, por ejemplo.
constantecola<flotador>que({1.1, 2.2, 3.3, 4.4, 5.5});costo<<que.parte delantera() << ' orte';
Se devuelve una referencia constante. El elemento no se elimina del vector. Los elementos de la cola no se pueden cambiar.
espalda()
Esto devuelve una referencia al último elemento de la cola, sin eliminar el elemento. El resultado del siguiente código es 5.5.
cola<flotador>que;que.empujar(1.1);que.empujar(2.2);que.empujar(3.3);que.empujar(4.4);que.empujar(5.5);
costo<<que.espalda() << ' orte';
atrás () const
Cuando la construcción de la cola está precedida por const, se ejecuta la expresión back () const en lugar de back (). Se utiliza en el siguiente código, por ejemplo.
constantecola<flotador>que({1.1, 2.2, 3.3, 4.4, 5.5});costo<<que.espalda() << ' orte';
Se devuelve una referencia constante. El elemento no se elimina de la cola. Con la constante anterior para la construcción de la cola, los elementos de la cola no se pueden cambiar.
Capacidad de la cola
tamaño () const
- véase más arriba
vacío () const
Esto devuelve 1 para verdadero si no hay elementos en la cola, o 0 para falso si la cola está vacía. El siguiente código ilustra esto:
cola<flotador>eso1({1.1, 2.2, 3.3, 4.4, 5.5});costo<<eso1.vacío() << ' orte';
cola<flotador>eso2;
costo<<eso2.vacío() << ' orte';
La salida es:
01
Modificadores de cola
pop()
Una cola es FIFO, por lo que cualquier elemento que deba eliminarse debe eliminarse de la parte superior (cabecera) de la cola. Esta función miembro elimina el primer elemento sin devolverlo. El siguiente código ilustra esto:
cola<flotador>que({1.1, 2.2, 3.3, 4.4, 5.5});costo<<que.parte delantera() << ' orte';
que.pop();
costo<<que.Talla() << ' orte';
La salida es:
1.14
cambiar (b)
Se pueden intercambiar dos colas, como se ilustra en este segmento de código:
cola<flotador>eso1({1.1, 2.2, 3.3, 4.4, 5.5});cola<flotador>eso2({10, 20});
eso1.intercambio(eso2);
costo<< 'Primer elemento y tamaño de que1:
'<<eso1.parte delantera() <<', '<<eso1.Talla() << ' orte';
costo<< 'Primer elemento y tamaño de que2'<<
eso2.parte delantera() <<', '<<eso2.Talla() << ' orte';
La salida es:
Primer elemento y tamaño de que1: 10, 2
Primer elemento y tamaño de que2: 1.1, 5
Tenga en cuenta que la longitud de una cola aumenta si es necesario. Además, los valores que no tuvieron reemplazos se reemplazan por algún valor predeterminado. Los tipos de datos deben ser del mismo tipo.
Operadores relacionales y de igualdad para colas
Para los caracteres ordinarios en C ++, en orden ascendente, los números van antes de las letras mayúsculas, que vienen antes de las minúsculas. El carácter de espacio viene antes de cero y todos ellos.
Operadores de igualdad
Devuelve 1 para verdadero y 0 para falso.
El == operador
Devuelve 1 si las dos colas tienen el mismo tamaño y los elementos correspondientes son iguales; de lo contrario, devuelve 0. Ejemplo:
cola<constante carbonizarse*>eso1({'amable', 'algo más'});cola<constante carbonizarse*>eso2({'malvado'});
En ten uno=eso1==eso2;
costo<<en uno<< ' orte';
La salida es: 0.
El! = Operador
- lo contrario de lo anterior. Ejemplo:
cola<constante carbonizarse*>eso1({'amable', 'algo más'});cola<constante carbonizarse*>eso2({'malvado'});
En ten uno=eso1!=eso2;
costo<<en uno<< ' orte';
La salida es: 1.
Operadores relacionales
Devuelve 1 para verdadero y 0 para falso.
los
Devuelve 1 si la primera cola es el subconjunto inicial de la segunda cola, con los elementos de las dos porciones iguales siendo iguales y en el mismo orden. Si ambas colas son del mismo tamaño o de diferentes tamaños, y moviéndose de izquierda a derecha, se encuentra un elemento en la primera cola que es menor que el elemento correspondiente en la segunda cola, entonces se devolverá 1. De lo contrario, se devuelve 0. Ejemplo:
cola<constante carbonizarse*>eso1({'amable', 'algo más'});cola<constante carbonizarse*>eso2({'malvado'});
En ten uno=eso1<eso2;
costo<<en uno<< ' orte';
La salida es 1. El> operador - lo contrario de lo anterior. Ejemplo: Salida: 0 los<= Operator - igual que Salida: 1 El> = operador - lo contrario de lo anterior. Ejemplo: Salida: 0 Un valor es para un tipo de datos, como un objeto instanciado es para una clase. La construcción de la cola también puede aceptar una clase como tipo de datos. El siguiente programa ilustra esto: La salida es 5. La lista de cola se denomina técnicamente lista enlazada. Hay dos tipos de listas enlazadas para la cola: lista enlazada individualmente y lista enlazada doblemente. Un elemento de lista enlazado individualmente se puede implementar mediante una estructura de dos miembros. Un miembro tiene un puntero al siguiente elemento y el otro miembro tiene el datum (singular para datos). Un elemento de lista doblemente enlazado se puede implementar mediante una estructura de tres miembros. El miembro del medio tiene el dato, mientras que el primer y tercer miembro tienen punteros a sus elementos adyacentes. La cola es una estructura de datos de primero en entrar, primero en salir. Hay situaciones en la informática en las que los datos llegan en forma de cola, lo que requiere un comportamiento de primero en entrar, primero en salir. Un recurso en una computadora es cualquier componente físico o virtual de disponibilidad limitada. Incluyen la CPU, la tarjeta de video, el disco duro y la memoria. Compartir tal recurso necesita una cola. Los periféricos de la computadora necesitan interrumpir la computadora de vez en cuando. Las interrupciones deben manejarse de la misma forma en que llegaron. Esto necesita una cola. La cola se puede utilizar, por ejemplo, para administrar archivos de aplicaciones para un trabajo, si los archivos están almacenados en la computadora. Una cola es una estructura de datos de lista, que es una lista enlazada individualmente o una lista enlazada doble. Por regla general, el primer elemento que entra en la lista es el primer elemento que sale. C ++ proporciona una estructura de datos de cola en su biblioteca estándar. Las categorías de funciones miembro y operadores disponibles para esta estructura son construcción de cola, acceso a elementos de cola, capacidad de cola, modificadores de cola y operadores sobrecargados de cola. Cualquier estructura de datos de cola debe proporcionar al menos las funciones miembro push () y pop (). push () significa enviar un nuevo elemento al final de la cola; y pop () significa, eliminar el elemento que está al principio de la cola. Desafortunadamente, en C ++, estas funciones no devuelven el valor insertado o emergente. Entonces, para conocer el último elemento antes de presionar, se debe usar la función adicional back (); y para conocer el primer elemento antes de hacer estallar, se debe usar la función adicional front (). Un valor es para un tipo de datos, como un objeto instanciado es para una clase. Por lo tanto, una clase particular se puede utilizar como tipo de datos para la instanciación de la plantilla de cola. Diferentes objetos para la clase se vuelven como diferentes valores para la clase. La cola tiene aplicaciones en la computadora. Se puede utilizar, por ejemplo, para administrar archivos de aplicaciones para un trabajo, si los archivos están almacenados en la computadora. Chrys
cola<constante carbonizarse*>eso2({'malvado'});
En ten uno=eso1>eso2;
costo<<en uno<< '
orte';
cola<constante carbonizarse*>eso2({'malvado'});
En ten uno=eso1<=eso2;
costo<<en uno<< '
orte';
cola<constante carbonizarse*>eso2({'malvado'});
En ten uno=eso1>=eso2;
costo<<en uno<< '
orte'; Clase y sus objetos instanciados
#incluir
usando el espacio de nombres std;
clase TheCla
{
público:
En ten uno;
estático carbonizarsech;
vacíofunción(carbonizarseno, constante carbonizarse *pag)
{
costo<< 'Existen ' <<en uno<< 'libros que valen' <<no<<pag<< ' en la tienda.' << '
orte';
}
estático vacíodivertida(carbonizarsech)
{
si (ch== 'a')
costo<< 'Función oficial de miembro estático' << '
orte';
}
};
En tprincipal()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;
cola<TheCla>que;
que.empujar(obj1);que.empujar(obj2);que.empujar(obj3);que.empujar(obj4);que.empujar(obj5);
costo<<que.Talla() << '
orte';
regreso 0;
} Lista enlazada
Aplicaciones de la cola
Compartir recursos informáticos
Manejo de interrupciones
Gestionar la información.
Conclusión