Cola (queue)

class Cola:
    """Una cola sobre un array circular: frente y final dan la vuelta al llegar al final del array."""
    def __init__(self):
        self._a = [None] * 4
        self._frente = self._tam = 0

    def encolar(self, x):
        if self._tam == len(self._a):
            self._crecer()
        self._a[(self._frente + self._tam) % len(self._a)] = x   # el final es frente + tam, dando la vuelta
        self._tam += 1

    def desencolar(self):
        if self._tam == 0:
            raise IndexError("cola vacía")
        x = self._a[self._frente]
        self._a[self._frente] = None
        self._frente = (self._frente + 1) % len(self._a)
        self._tam -= 1
        return x

    def vacia(self):
        return self._tam == 0

    def _crecer(self):                                         # se copia en orden a un array el doble de grande
        self._a = [self._a[(self._frente + i) % len(self._a)] for i in range(self._tam)] + [None] * len(self._a)
        self._frente = 0


impresora = Cola()
for doc in ["apuntes.pdf", "foto.png", "examen.docx"]:
    impresora.encolar(doc)
    print("En cola:", doc)
print("Imprimiendo", impresora.desencolar())
impresora.encolar("factura.pdf")
print("En cola: factura.pdf")
while not impresora.vacia():
    print("Imprimiendo", impresora.desencolar())

/** Una cola sobre un array circular: frente y final dan la vuelta al llegar al final del array. */
class Cola {
    #a = new Array(4).fill(null);
    #frente = 0;
    #tam = 0;

    encolar(x) {
        if (this.#tam === this.#a.length) this.#crecer();
        this.#a[(this.#frente + this.#tam) % this.#a.length] = x;   // el final es frente + tam, dando la vuelta
        this.#tam++;
    }

    desencolar() {
        if (this.#tam === 0) throw new Error("cola vacía");
        const x = this.#a[this.#frente];
        this.#a[this.#frente] = null;
        this.#frente = (this.#frente + 1) % this.#a.length;
        this.#tam--;
        return x;
    }

    vacia() { return this.#tam === 0; }

    #crecer() {                                                   // se copia en orden a un array el doble de grande
        const b = new Array(2 * this.#a.length).fill(null);
        for (let i = 0; i < this.#tam; i++) b[i] = this.#a[(this.#frente + i) % this.#a.length];
        this.#a = b;
        this.#frente = 0;
    }
}

const impresora = new Cola();
for (const doc of ["apuntes.pdf", "foto.png", "examen.docx"]) {
    impresora.encolar(doc);
    console.log("En cola: " + doc);
}
console.log("Imprimiendo " + impresora.desencolar());
impresora.encolar("factura.pdf");
console.log("En cola: factura.pdf");
while (!impresora.vacia()) console.log("Imprimiendo " + impresora.desencolar());

using System;

// Una cola sobre un array circular: frente y final dan la vuelta al llegar al final del array.
class Cola<T> {
    private T?[] a = new T?[4];
    private int frente = 0, tam = 0;

    public void Encolar(T x) {
        if (tam == a.Length) Crecer();
        a[(frente + tam) % a.Length] = x;          // el final es frente + tam, dando la vuelta
        tam++;
    }

    public T Desencolar() {
        if (tam == 0) throw new InvalidOperationException("cola vacía");
        T x = a[frente]!;
        a[frente] = default;
        frente = (frente + 1) % a.Length;
        tam--;
        return x;
    }

    public bool Vacia => tam == 0;

    private void Crecer() {                       // se copia en orden a un array el doble de grande
        var b = new T?[2 * a.Length];
        for (int i = 0; i < tam; i++) b[i] = a[(frente + i) % a.Length];
        a = b;
        frente = 0;
    }
}

class Program {
    static void Main() {
        var impresora = new Cola<string>();
        foreach (var doc in new[] { "apuntes.pdf", "foto.png", "examen.docx" }) {
            impresora.Encolar(doc);
            Console.WriteLine("En cola: " + doc);
        }
        Console.WriteLine("Imprimiendo " + impresora.Desencolar());
        impresora.Encolar("factura.pdf");
        Console.WriteLine("En cola: factura.pdf");
        while (!impresora.Vacia) Console.WriteLine("Imprimiendo " + impresora.Desencolar());
    }
}

<?php
/** Una cola sobre un array circular: frente y final dan la vuelta al llegar al final del array. */
class Cola {
    private array $a;
    private int $frente = 0;
    private int $tam = 0;

    public function __construct() { $this->a = array_fill(0, 4, null); }

    public function encolar(mixed $x): void {
        if ($this->tam === count($this->a)) $this->crecer();
        $this->a[($this->frente + $this->tam) % count($this->a)] = $x;   // el final es frente + tam, dando la vuelta
        $this->tam++;
    }

    public function desencolar(): mixed {
        if ($this->tam === 0) throw new UnderflowException("cola vacía");
        $x = $this->a[$this->frente];
        $this->a[$this->frente] = null;
        $this->frente = ($this->frente + 1) % count($this->a);
        $this->tam--;
        return $x;
    }

    public function vacia(): bool { return $this->tam === 0; }

    private function crecer(): void {                                   // se copia en orden a un array el doble de grande
        $b = array_fill(0, 2 * count($this->a), null);
        for ($i = 0; $i < $this->tam; $i++) $b[$i] = $this->a[($this->frente + $i) % count($this->a)];
        $this->a = $b;
        $this->frente = 0;
    }
}

$impresora = new Cola();
foreach (["apuntes.pdf", "foto.png", "examen.docx"] as $doc) {
    $impresora->encolar($doc);
    echo "En cola: $doc\n";
}
echo "Imprimiendo " . $impresora->desencolar() . "\n";
$impresora->encolar("factura.pdf");
echo "En cola: factura.pdf\n";
while (!$impresora->vacia()) echo "Imprimiendo " . $impresora->desencolar() . "\n";

from collections import deque

# deque es una cola doble: append encola por el final y popleft saca por el principio, ambas O(1)
cola = deque()
cola.append("Ana")
cola.append("Luis")
primero = cola[0]               # "Ana", sin sacarlo
sale = cola.popleft()           # "Ana" (con la cola vacía lanzaría IndexError)
# No uses list.pop(0): desplaza toda la lista, O(n)

// JavaScript no trae una cola eficiente: shift() desplaza todo el array (O(n)).
// Para colas grandes, un índice al frente evita mover nada:
const cola = [];
let frente = 0;
cola.push("Ana");                        // encolar por el final
cola.push("Luis");
const primero = cola[frente];            // "Ana", sin sacarlo
const sale = cola[frente++];             // "Ana"; la cola son las posiciones frente..cola.length-1

// En C#, Queue<T> (un array circular por dentro)
var cola = new Queue<string>();
cola.Enqueue("Ana");                         // encolar por el final
cola.Enqueue("Luis");
string primero = cola.Peek();                // "Ana", sin sacarlo
string sale = cola.Dequeue();                // "Ana"
bool hay = cola.TryDequeue(out var otro);    // sin excepción si está vacía

// En PHP, SplQueue (o un array con array_shift, que es O(n))
$cola = new SplQueue();
$cola->enqueue("Ana");               // encolar por el final
$cola->enqueue("Luis");
$primero = $cola->bottom();          // "Ana", sin sacarlo
$sale = $cola->dequeue();            // "Ana"