Cola Circular

Una cola circular es una variante de la cola lineal que supera eficazmente la limitación de la cola lineal. En la cola circular, el nuevo elemento se agrega en la primera posición de la cola si el último está ocupado y hay espacio disponible. Cuando se trata de cola lineal, la inserción se puede realizar solo desde la parte trasera y la eliminación desde la parte delantera. En una cola completa, después de realizar una serie de eliminaciones sucesivas en la cola, surge una situación determinada en la que no se puede agregar ningún elemento nuevo incluso si el espacio disponible porque la condición de subdesbordamiento (Posterior = máx.

La cola circular conecta los dos extremos a través de un puntero donde el primer elemento viene después del último elemento. También realiza un seguimiento de la parte delantera y trasera implementando una lógica adicional para poder rastrear los elementos que se insertarán y eliminarán. Con esto, la cola circular no genera la condición de desbordamiento hasta que la cola está llena en realidad.

Algunas condiciones seguidas por la cola circular:

✓ El frente debe apuntar al primer elemento. ✓ La cola estará vacía si Front = Rear. ✓ Cuando se agrega un nuevo elemento, la cola se incrementa en el valor uno (Posterior = Posterior + 1). ✓ Cuando se elimina un elemento de la cola, el anverso se incrementa en uno (Anverso = Anverso + 1).

Este tipo de estructura obliga a dejar siempre una posición libre para separar el principio del final, pero evidentemente siempre existirá la limitación de que podrá llenarse completamente la cola.

Operaciones Básicas de la C O L A C I R C U L A R

Colas circulares (anillos): En las que el último elemento y el primero están unidos.

Los elementos pueden consultarse, añadirse y eliminarse únicamente desde la cabeza del anillo que es una posición distinguida. Existen dos operaciones de rotaciones, una en cada sentido, de manera que la cabeza del anillo pasa a ser el elemento sucesor, o el predecesor, respectivamente, de la cabeza actual.

Anillo en Maude

fmod ANILLO {X :: TRIV} is sorts AnilloNV{X} Anillo{X} . subsort AnilloNV{X} < Anillo{X} .

Int num; If(vacía()) No funcia code op crear : -> Anillo{X} [ctor] . op insertar : X$Elt Anillo{X} -> AnilloNV {X} [ctor] .

-> Anillo{X} . ops rotarDch rotarIzq : Anillo{X} -> Anillo{X} . op cabeza : AnilloNV{X} -> X$Elt . op esVacio? : Anillo{X} -> Bool . op aLaCola : X$Elt Anillo{X} -> Anillo{X} . op elimCola : Anillo{X} -> Anillo{X} . op cola : AnilloNV {X} -> X$Elt .

var A : Anillo{X} . vars E E2 : X$Elt .

eq eliminar(crear) = crear . eq eliminar(insertar(E, A)) = A .

eq cabeza(insertar(E, A)) = E .

eq esVacio?(crear) = true . eq esVacio?(insertar(E, A)) = false .

eq cola(insertar(E, crear)) = E . eq cola(insertar(E, insertar(E2, A))) = cola(insertar(E2, A)) .

eq elimCola(crear) = crear . eq elimCola(insertar(E, crear)) = crear . eq elimCola(insertar(E, insertar(E2, A))) = insertar(E, elimCola(insertar(E2, A))) .

eq aLaCola(E, crear) = insertar(E, crear) . eq aLaCola(E, insertar(E2, A)) = insertar(E2, aLaCola(E, A)) .

ANILLOS

en Pseudolenguaje

FUNC CrearCola() : TCola VARIABLES cola: TCola INICIO

cola.frente <- MAXCOLA cola.final <- MAXCOLA RESULTADO <- cola

FIN

PROC DestruirCola(&cola: TCola) INICIO //Sin modificaciones FIN

FUNC ColaLlena(cola: TCola): LÓGICO INICIO

FIN RESULTADO <- (cola.final MOD MAXCOLA) + 1 = cola.frente

FUNC ColaVacia(cola: TCola): LÓGICO INICIO

RESULTADO <- cola.final = cola.frente

FIN

PROC MeterCola (&cola: TCola; &e: Telemento; &error: Terror) VARIABLES fin: NATURAL INICIO

SI ColaLlena(cola) ENTONCES error <- ErrorColaLlena EN OTRO CASO error <- NoError fin <- (cola.final MOD MAXCOLA) + 1 cola.final <- fin cola.elementos[fin] <- e

FINSI

FIN

PROC SacarCola (&cola: TCola; &e: Telemento; &error: Terror) VARIABLES ini: NATURAL

INICIO

SI ColaVacia(cola) ENTONCES error <- ErrorColaLlena EN OTRO CASO error <- NoError ini <- (cola.frente MOD MAXCOLA) + 1 cola.frente <- ini e <- cola.elementos[ini]

Algoritmos

Insertar un elemento en la cola

Extraer un elemento de la cola

La notación di+1 -> di significa que el elemento situado en la posición i+1 debe ser copiado a la posición i. Esto es lo que ocurre en la vida cotidiana, en concreto, cuando una persona ha acabado su gestión en la ventanilla y la abandona, los demás deben moverse hacia adelante, es decir, el segundo pasa a ser el primero, el tercero al segundo y así sucesivamente. Para una cola pequeña, este algoritmo es sencillo y eficaz, pero cuando la cola es grande, el corrimiento de datos puede suponer un gasto de tiempo que enlentece el programa, razón por la cual, mostramos a continuación otro procedimiento mucho mejor para evitar este problema.