¿Qué es un búfer circular (ring buffer) y cuándo lo utilizarías?

Question

Accepted Answer

Un **búfer circular** es un array de tamaño fijo tratado como si sus extremos estuvieran unidos en un anillo. Dos índices — **head** (lectura) y **tail** (escritura) — avanzan y se envuelven usando aritmética de módulo, proporcionando una cola FIFO O(1) **sin asignación** después de la creación.

## Cómo funciona el envolvimiento

```text
capacity 5, after writing A,B,C,D and reading A,B:
index:  0   1   2   3   4
      [ . ][ . ][ C ][ D ][ . ]
              head^       tail^   (tail wraps to 0 next write)
```

## Code

```python
class RingBuffer:
    def __init__(self, n):
        self.buf = [None]*n
        self.head = self.tail = self.size = 0
        self.cap = n
    def enqueue(self, x):                  # O(1)
        if self.size == self.cap: raise Exception("full")
        self.buf[self.tail] = x
        self.tail = (self.tail + 1) % self.cap   # wrap
        self.size += 1
    def dequeue(self):                     # O(1)
        x = self.buf[self.head]
        self.head = (self.head + 1) % self.cap    # wrap
        self.size -= 1
        return x
```

| Operación | Tiempo |
|---|---|
| enqueue / dequeue | O(1) |
| space | O(n) fijo |

## Cuándo usarlo

- **Búferes de transmisión / audio / video** — acotados, rendimiento constante.
- **Tuberías productor–consumidor** con backpressure.
- **Registro de los últimos N eventos** (sobrescribir el más antiguo).

## Por qué es importante

Un búfer circular proporciona un comportamiento FIFO predecible y sin asignación, que es esencial en sistemas de tiempo real e integrados donde la asignación dinámica es demasiado lenta o riesgosa.

Su tamaño acotado también actúa como backpressure natural, evitando que productores rápidos agoten la memoria.