Estructura de Datos: Colas (FIFO) y sus Implementaciones, Esquemas y mapas conceptuales de Matemáticas

¡Descarga Estructura de Datos: Colas (FIFO) y sus Implementaciones y más Esquemas y mapas conceptuales en PDF de Matemáticas solo en Docsity!

Unidad de Apoyo a la Formación Académica

Estructura de Datos

Tema n.°

Colas

Unidad de Apoyo a la Formación Académica

Índice

Pág.

Introducción 3

4.1. Implementaciones de colas 3

4.1.1. Representación en memoria estática y dinámica 5

4.1.2. Tipos de colas 18

4.1.3. Operaciones con colas 22

Recursos complementarios 30

Referencias 30

Autoevaluación 32

Unidad de Apoyo a la Formación Académica

Los elementos se eliminan (se quitan) de la cola en el mismo orden en que se

almacenan y, por consiguiente, una cola es una estructura de tipo FIFO (first-in/firs-

out, primero entrar/primero en llegar/primero en ser servido). (Hernández Bejarano &

Baquero Rey, 2021)

Definición

Una cola es una estructura de datos cuyos elementos mantienen un cierto

orden, tal que solo se pueden añadir elementos por un extremo ( final de la cola) y

eliminar o extraer por el otro extremo (llamado frente).

Las operaciones usuales en las colas son insertar y quitar. La operación

insertar añade un elemento por el extremo final de la cola y la operación quitar

elimina o extrae un elemento por el extremo opuesto, el frente o primero de la cola.

La organización de elementos en forma de cola asegura que el primero en entrar es

el primero en salir. En la figura 2 se realizan las operaciones básicas sobre colas,

insertar y retirar elementos. (Hernández Bejarano & Baquero Rey, 2021)

Figura 2

Operaciones insertar y quitar en una cola

Unidad de Apoyo a la Formación Académica

4.1.1. Representación en memoria estática y dinámica

Memoria estática

Para modelar una cola finita en forma de un array o vector, la tarea se vuelve

un tanto más desafiante en comparación con la implementación de una pila.

Además de la matriz unidimensional, se deben incorporar variables adicionales que

indiquen las posiciones inicial y final de la cola, así como el tamaño del vector.

Una estrategia eficiente consiste en visualizar el vector que almacena la

información de la cola como si fuera circular. De esta manera, se posibilita la

inserción de nuevos elementos en la cola incluso cuando los primeros elementos de

la matriz unidimensional están vacíos. Esto facilita la gestión del espacio y optimiza

el rendimiento de la cola, permitiendo una operación más suave de inserción. (De la

Cuerva Hernández et al., 2020, p. 250)

Características

• Es la memoria de la cual se conoce su tamaño en el momento de la compilación.

• Es el espacio de memoria que se crea cuando se declaran las variables de

cualquier tipo de datos.

• La memoria que estas variables ocupan no puede cambiarse durante la ejecución

y tampoco puede ser liberada manualmente.

• Al ser una cola estática ya no es necesaria la existencia de un nodo.

Unidad de Apoyo a la Formación Académica }

ColaEstatica.h

**pragma once

class ColaEstatica** { private: int frente, final; int * arreglo; int tamano; public: ColaEstatica( int t); ~ColaEstatica(); bool estaVacia (); bool estaLlena (); void agregar ( int valor); void eliminar (); void mostrar (); };

ColaEstatica.cpp

#include "ColaEstatica.h" #include ColaEstatica::ColaEstatica( int t) : tamano(t) { frente = final = - 1 ; arreglo = new int [tamano]; } ColaEstatica::~ColaEstatica() { delete [] arreglo; } bool ColaEstatica::estaVacia() { return frente == - 1 && final == - 1 ; } bool ColaEstatica::estaLlena() { return (final + 1 ) % tamano == frente; } void ColaEstatica::agregar( int valor) {

Unidad de Apoyo a la Formación Académica if (estaLlena()) { std::cout << " \n\n La cola esta llena. No se puede agregar." << std::endl; system("pause"); return ; } if (estaVacia()) { frente = final = 0 ; } else { final = (final + 1 ) % tamano; } arreglo[final] = valor; } void ColaEstatica::eliminar() { if (estaVacia()) { std::cout << " \n\n La cola esta vacia. No se puede eliminar." << std::endl; system("pause"); return ; } std::cout << " \n\n Se elimino el elemento " << arreglo[frente] << " de la cola." << std::endl; system("pause"); if (frente == final) { frente = final = - 1 ; } else { frente = (frente + 1 ) % tamano; } } void ColaEstatica::mostrar() { if (estaVacia()) { std::cout << " \n\n La cola esta vacia." << std::endl; return ; }

Unidad de Apoyo a la Formación Académica } } datos[i] = '\0'; return atoi(datos); }

Figura 3

Ejecución código operaciones de una cola estática

Unidad de Apoyo a la Formación Académica

Unidad de Apoyo a la Formación Académica

Características

• Es memoria que se asigna, une tiempo de ejecución del programa.

• Su tamaño puede variar durante el tiempo de ejecución.

Código ejemplo

Main.cpp

#include "ColaDinamica.h" #include "Validacion.h" #include int main () { ColaDinamica cola; bool continuar = true; do { system("cls"); std::cout << " \n\t COLA DINAMICA \n\n " << "1. Agregar \n " << "2. Eliminar \n " << "3. Mostrar \n " << "4. Salir \n\n "; switch (ingresar_enteros("Ingresar la opcion: ")) { case 1 : cola.agregar(ingresar_enteros(" \n\n Ingresar un numero: ")); break ; case 2 : cola.eliminar(); break ; case 3 : cola.mostrar(); system("pause"); break ;

Unidad de Apoyo a la Formación Académica case 4 : continuar = false; break ; default: break ; } } while (continuar); return 0 ; }

ColaDinamica.h

#pragma once #include "Nodo.h" class ColaDinamica { private: Nodo* frente; Nodo* final; public: ColaDinamica(); ~ColaDinamica(); bool estaVacia (); void agregar ( int valor); void eliminar (); void mostrar (); }; ColaDinamica.cpp #include "ColaDinamica.h" #include ColaDinamica::ColaDinamica() : frente(nullptr), final(nullptr) {} ColaDinamica::~ColaDinamica() { while (!estaVacia()) { eliminar(); } } bool ColaDinamica::estaVacia() { return frente == nullptr; }

Unidad de Apoyo a la Formación Académica

Nodo.h

#pragma once class Nodo { public: int dato; Nodo* siguiente; Nodo( int valor); ~Nodo(); };

Nodo.cpp

#include "Nodo.h" Nodo::Nodo( int valor) : dato(valor), siguiente(nullptr) {} Nodo::~Nodo() { delete siguiente; }

Validacion.h

#pragma once #include #include int borrar ( char * datos, int & i) { if (i > 0 ) { printf(" \b \b "); i--; datos[i] = '\0'; return i; } return 0 ; } int ingresar_enteros (std::string msj) { char * datos = new char [ 10 ]; char c; int i = 0 ;

Unidad de Apoyo a la Formación Académica std::cout << msj; while ((c = _getch()) != 13 && i < 9 ) { if ((c >= '0' && c <= '9') || c == 8 ) { if (c == 8 ) { i = borrar(datos, i); } else { printf("%c", c); datos[i++] = c; } } } datos[i] = '\0'; return atoi(datos); }

Figura 4

Ejecución código operaciones de una cola dinámica

Unidad de Apoyo a la Formación Académica

servicio no se proporciona únicamente aplicando el concepto “primero en llegar

primero en ser atendido” sino que cada objeto tiene asociado una prioridad basada

en un criterio objetivo. La cola de prioridad es una estructura ordenada que se utiliza

para guardar elementos en un orden establecido. (Hernández Bejarano & Baquero

Rey, 2021, p. 366 )

Hay que seguir estas reglas.

• Se elige la cola no vacía que se corresponda con la mayoría de prioridad.

• En la cola de mayor prioridad, los elementos se procesan según el orden de

llegada: primero en entrar primero en salir.

Las colas de prioridad son muy importantes en la implementación de

algoritmos ávidos y en la simulación de eventos. Un ejemplo de organización

formando colas de prioridades es el sistema de tiempo compartido, necesario para

mantener una serie de procesos que esperan ser ejecutados por el procesador.

Cada proceso lleva asociado una prioridad, de tal manera que se ejecuta siempre el

proceso de mayor prioridad y dentro de la misma prioridad, aquel proceso que

primero llega. Otro posible ejemplo que se realiza es con una cola de prioridad en la

simulación de sucesos que ocurren en un tiempo discreto, como es la atención de

una fila de clientes en un sistema de n ventanillas de despacho de billetes de

transporte. (Hernández Bejarano & Baquero Rey, 2021 )

En la figura 5, se muestra el orden para extraer un elemento de la estructura.

Unidad de Apoyo a la Formación Académica

Figura 5

Prioridad de elementos de la cola

Colas circulares

Una cola circular es aquella en la cual el sucesor del último elemento es el

primero; por lo tanto, el manejo de las colas como estructuras circulares permite un

mejor uso del espacio de memoria reservado para la implementación de las mismas.

La figura 6 corresponde a la representación gráfica de una cola circular. Observe

que el siguiente elemento del último es el primero. (Guardati Buemo, 20 0 7, p. 231)

Figura 6

Estructura de una cola circular

La figura 7 presenta el esquema correspondiente a una cola circular, en la

cual el final se movió hacia el inicio de la cola, teniendo un valor menor al frente. En

este ejemplo, (Guardati Buemo, 200 7) la cola tiene las posiciones 4 a MAX-1 y 0 a 1

ocupadas, siendo el primer elemento a salir el que está en la posición 4 y el último

insertado el que está en la posición 1.