La Cola de la lección anterior crece sin límite: mientras haya memoria, acepta elementos. Pero muchos sistemas trabajan con memoria fija: un buffer de red, el búfer de teclado, el registro de los últimos eventos de una aplicación. Para esos casos existe una implementación clásica y elegantísima: la cola circular (o ring buffer), una cola FIFO montada sobre un array de capacidad fija cuyos índices, al llegar al final, "dan la vuelta" y reutilizan las casillas liberadas por el frente. En esta lección construiremos la clase ColaCircular con aritmética modular, resolveremos el rompecabezas de distinguir "llena" de "vacía", y la aplicaremos a TaskFlow: el registro de los últimos N eventos del sistema. También conectaremos la idea con una vieja conocida: la ListaCircular del módulo 2.

1. El problema: una cola sobre array fijo
2. La idea circular: aritmética modular
3. El rompecabezas: ¿llena o vacía?
4. La clase ColaCircular
5. Traza visual del avance modular
6. Ring buffers en el mundo real y relación con ListaCircular
7. TaskFlow: RegistroEventos, los últimos N eventos

Supongamos que solo disponemos de un array de capacidad fija, digamos 5 casillas, y queremos una cola FIFO sobre él. El primer intento ingenuo: encolar avanzando un índice final y desencolar avanzando un índice frente:

Tras desencolar A y B, las casillas 0 y 1 están libres... pero final sigue avanzando hacia la derecha. Cuando final llegue a la casilla 4, la cola parecerá "llena" con dos casillas desperdiciadas a la izquierda. Las alternativas malas son dos:

• Desplazar los elementos hacia la izquierda en cada desencolado: eso es exactamente el pop(0) O(n) que llevamos dos módulos evitando.
• Rechazar inserciones aunque haya hueco: desperdicio inaceptable en un buffer.

La solución buena: que final, al pasarse del borde derecho, continúe por la casilla 0. El array deja de ser una tira y se convierte, conceptualmente, en un anillo.

Para "dar la vuelta" no hace falta magia, basta el operador módulo %. Si la capacidad es c, el índice siguiente a i es:

Con c = 5: después del 3 viene el 4, y después del 4 viene (4 + 1) % 5 = 0. El módulo convierte la recta de índices en un círculo:

¿Te suena? Es la misma idea que la ListaCircular del módulo 2, donde el último nodo apuntaba al primero (ultimo.siguiente) y el RepartidorTareas giraba indefinidamente. Allí el círculo se construía con enlaces entre nodos; aquí se construye con aritmética sobre índices de un array. Mismo concepto, implementación distinta — y esta versión, al ser un array contiguo de tamaño fijo, es más compacta en memoria y más amiga de la caché del procesador, por eso es la elegida en drivers y sistemas embebidos.

Hay una sutileza famosa. Si representamos la cola solo con los índices frente y final, la condición frente == final es ambigua: ocurre tanto cuando la cola está vacía como cuando está llena (el final ha dado la vuelta completa y ha alcanzado al frente). Hay dos soluciones clásicas:

Nosotros usaremos el contador, que además nos da tamano() gratis (está en el contrato). La estrategia de la casilla sacrificada la verás en código C de bajo nivel, donde evitar un campo extra importa; conviene reconocerla cuando la leas.

Con contador, ni siquiera necesitamos almacenar final: se deduce de frente y tamano:

Menos estado que mantener significa menos invariantes que romper: es un principio de diseño que ya aplicamos en la ListaCircular (solo guardábamos self.ultimo).

Puntos que merecen explicación detallada:

• Todo es O(1), sin letra pequeña: encolar y desencolar hacen una escritura, una suma y un módulo. No hay desplazamientos (el gran pecado de ColaLenta) ni nodos que crear (a diferencia de la Cola enlazada). Tampoco hay redimensionados: la memoria se reserva una única vez en __init__.
• self._datos[self._frente] = None en desencolar: no es obligatorio para que funcione, pero si la casilla retiene la referencia al objeto, Python no puede liberarlo de memoria hasta que la casilla se sobrescriba. En colas de rotación lenta eso mantiene vivos objetos "fantasma". Es el mismo tipo de higiene que las referencias colgantes del módulo 2.
• OverflowError al llenarse: la cola fija debe decidir su política de saturación. Lanzar excepción es la política honesta por defecto; en el ejemplo de TaskFlow veremos la otra política habitual (descartar lo más antiguo). Lo importante es que sea una decisión explícita.

Sigamos una ColaCircular(4) operación a operación. Marcamos F bajo el índice frente y calculamos final = (frente + tamano) % 4 (casilla del próximo encolado):

Las dos filas en negrita cuentan la historia completa:

• Tras encolar(D), el próximo final es (1 + 3) % 4 = 0: ha dado la vuelta. Por eso E aterriza en la casilla 0, que A dejó libre. Ninguna casilla se desperdicia, nada se desplaza.
• Con la cola llena (tamano == 4), frente vale 1 y la casilla del "final" coincidiría con él: exactamente la ambigüedad que el contador resuelve.

Observa también que el orden FIFO se conserva perfectamente aunque físicamente E esté "antes" que B en el array: el orden lógico lo dictan frente y el avance modular, no la posición física. Es la distinción TDA/implementación del módulo 1 en su versión más gráfica.

El nombre profesional de esta estructura es ring buffer (buffer circular) y aparece en cuanto rascas cualquier sistema:

• Buffers de teclado y de red: el hardware produce bytes a su ritmo; el software los consume al suyo. Un ring buffer de tamaño fijo absorbe la diferencia sin pedir memoria jamás (crucial en un driver, donde no se puede "pedir más memoria").
• Audio y vídeo en streaming: el reproductor lee del frente mientras la descarga escribe por el final; si la descarga se adelanta demasiado, espera (cola llena); si se retrasa, el reproductor espera (cola vacía).
• Logs de últimos eventos: journals del sistema, cajas negras de aviónica, el historial "últimos N" de cualquier aplicación: se sobrescribe lo viejo automáticamente.

Comparativa con su prima del módulo 2:

En TaskFlow queremos un panel de "actividad reciente": los últimos 100 eventos del sistema (tarea creada, completada, reasignada...). No queremos guardarlos todos —para eso ya habrá una base de datos—, solo los N más recientes, con memoria constante. Es el caso de uso perfecto del ring buffer con política de descartar lo más antiguo:

Dos decisiones dignas de comentario:

• registrar implementa "descartar lo viejo" componiendo el contrato público (esta_llena + desencolar + encolar), sin tocar las tripas de ColaCircular. La política vive en la capa de TaskFlow; la estructura queda genérica y reutilizable.
• actividad_reciente usa el truco de la rotación completa: desencola cada elemento y lo vuelve a encolar, de modo que tras tamano() vueltas la cola queda exactamente como estaba. Es la manera de recorrer una cola respetando su contrato (sin acceder al array interno).

Quizá recuerdes que el HistorialConLimite del módulo 3 hacía algo parecido ("quedarme con los últimos k") pagando un pop(0) O(n). El RegistroEventos ya lo hace todo en O(1)... a costa de fijar la capacidad de antemano. En la lección 04-05 veremos la tercera vía, la más pythónica: deque(maxlen=k).

• Olvidar el % en algún avance: si escribes self._frente += 1 sin módulo, la cola funciona de maravilla... hasta la primera vuelta, y entonces indexa fuera del array (IndexError) o lee basura. Los errores "de segunda vuelta" son traicioneros porque las pruebas cortas no los detectan: prueba siempre con más operaciones que capacidad.
• Usar frente == final como prueba de vacía con solo dos índices: es la ambigüedad llena/vacía. Decide estrategia (contador o casilla sacrificada) y sé consecuente; con contador, ni compares índices.
• Confundir capacidad con tamaño: capacidad() es cuántos caben; tamano() es cuántos hay. En el código de saturación (esta_llena) se comparan entre sí, y mezclarlos produce colas que "se llenan" a la mitad.
• Elegir mal la política de saturación: ¿excepción, descartar lo nuevo o descartar lo viejo? Para un buffer de comandos de un usuario, perder lo nuevo suele ser peor; para un registro de actividad, perder lo viejo es justo lo deseado. No hay política universal: documenta la elegida.
• Consejo: al depurar una cola circular, imprime siempre la tripleta (frente, tamano, capacidad) junto al array. Ver frente = 3, tamano = 2 sobre [E][·][·][D] te enseña más que veinte print del array solo.

Sobre una ColaCircular(3), ejecuta en orden: encolar(1), encolar(2), desencolar(), encolar(3), encolar(4), desencolar(), desencolar(), encolar(5). Construye la tabla de traza (array, frente, tamano, valor devuelto) tras cada operación. ¿En qué casilla física acaba el 5 y por qué?

Añade a ColaCircular un método ultimo_encolado() que devuelva (sin extraer) el elemento más reciente, lanzando IndexError si la cola está vacía. Cuidado: la casilla del último elemento no es (frente + tamano) % capacidad (esa es la del próximo). Hazlo en O(1).

Escribe un método redimensionar(nueva_capacidad) que sustituya el array interno por uno de la nueva capacidad, conservando los elementos en orden FIFO y dejando frente = 0. Debe rechazar con ValueError una capacidad menor que tamano(). Pista: no copies casillas por posición física; recoloca siguiendo el orden lógico, con índices modulares desde el frente antiguo.

Solución 1:

El 4 cayó en la casilla 0 porque (1 + 2) % 3 = 0 (primera vuelta), y el 5 cae en la casilla 1 porque, con frente = 0 y tamano = 1, el próximo final es (0 + 1) % 3 = 1. El orden lógico (frente→final) es 4, 5, aunque el 4 esté físicamente antes: el FIFO lo dictan los índices, no la posición.

Solución 2:

El - 1 dentro del módulo maneja también el caso de la vuelta: con frente = 2, tamano = 1, capacidad = 3, el último está en (2 + 1 - 1) % 3 = 2, correcto. En Python, incluso (0 - 1) % 3 da 2 (el módulo de Python nunca es negativo), así que la fórmula es segura.

Solución 3:

La clave es el índice (self._frente + i) % self._capacidad: recorre los elementos en orden FIFO real, aunque estén partidos en dos tramos físicos (final del array + principio). Copiar el array tal cual (self._datos[:]) sería un error: mezclaría casillas vacías en medio y rompería el orden.

La cola circular resuelve el problema de la cola sobre memoria fija: dos índices que avanzan con aritmética modular ((i + 1) % capacidad), un contador que deshace la ambigüedad llena/vacía, y todas las operaciones en O(1) sin desplazar jamás un elemento. Es la versión "de array" de la idea que ya vimos con enlaces en la ListaCircular, y es la estructura de los ring buffers que sostienen drivers, streaming y registros de actividad — incluido nuestro RegistroEventos de los últimos N eventos de TaskFlow. Hasta ahora, todas nuestras colas comparten un dogma: sale el más antiguo. Pero en TaskFlow hay tareas con prioridad 1 que no pueden esperar su turno detrás de veinte tareas rutinarias. Toca romper el dogma con cabeza: en la próxima lección, la cola de prioridad, donde desencolar significa "dame el más urgente" — y donde por fin extraeremos aquello que el min-stack del módulo 3 solo podía mirar.