Fila

Acompanhe passo a passo uma fila em C++ construída com nós.

Tudo é simulado neste navegador; nada é enviado a nenhum servidor.

Valores

Criar o novo nó

Criar o novo nó

n_ = 0

A fila está vazia

  • Recém-adicionado
  • Saindo agora

Passo 1 / 54

Código

#include <iostream>
using namespace std;
class Nodo { // Um nó guarda o dado e um ponteiro para o próximo
private: // Atributos privados: só os métodos acessam
int dato;
Nodo* siguiente;
public:
Nodo(int d) : dato(d), siguiente(nullptr) {}
int getDato() const { return dato; }
Nodo* getSiguiente() const { return siguiente; }
void setDato(int d) { dato = d; }
void setSiguiente(Nodo* s) { siguiente = s; }
};
class Cola {
private: // frente_ é o próximo a sair e final_ o último a chegar
Nodo* frente_; // Primeiro nó da fila
Nodo* final_; // Último nó da fila
int n_; // Número de nós
public:
Cola() : frente_(nullptr), final_(nullptr), n_(0) {}
// Destructor (no se anima)
~Cola() {
while (frente_ != nullptr) desencolar();
}
void encolar(int valor) { // Enfileirar no final: O(1)
Nodo* nuevo = new Nodo(valor); // Criar o nó
if (final_ == nullptr) { // A fila está vazia?
frente_ = final_ = nuevo; // É o único nó: frente_ e final_ apontam para ele
} else {
final_->setSiguiente(nuevo); // O último nó aponta para o novo
final_ = nuevo; // final_ agora aponta para o novo nó
}
n_++;
}
void desencolar() { // Desenfileirar o primeiro: O(1)
if (frente_ == nullptr) return; // Fila vazia: nada a remover
Nodo* temp = frente_; // Guardar o primeiro para poder liberá-lo
frente_ = frente_->getSiguiente(); // frente_ avança para o próximo nó
if (frente_ == nullptr) final_ = nullptr; // Fila vazia: final_ não aponta mais para nada
delete temp; // Liberar a memória
n_--;
}
// Muestra la cola del frente al final
void imprimir() const {
cout << "frente ->";
for (Nodo* p = frente_; p != nullptr; p = p->getSiguiente())
cout << " " << p->getDato();
cout << endl;
}
};
int main() {
Cola cola;
cola.encolar(3);
cola.encolar(6);
cola.encolar(9);
cola.imprimir(); // frente -> 3 6 9
cola.desencolar();
cola.imprimir(); // frente -> 6 9
cola.encolar(1);
cola.imprimir(); // frente -> 6 9 1
return 0;
}

Este visualizador de fila explica uma estrutura FIFO, em que o primeiro elemento a entrar é o primeiro a sair. A fila é construída com nós em C++ e dois ponteiros: frente_, que aponta para o próximo elemento a sair, e final_, que aponta para o último inserido. Você pode embaralhar uma sequência aleatória ou adicionar você mesmo operações de enqueue e dequeue, até 12. A animação cobre o caso especial da fila vazia, como o último nó se liga ao novo e quando final_ vira nullptr depois que a fila se esvazia. Cada passo destaca sua linha de código e tudo é calculado no seu navegador.

Como usar

  1. Escolha o tamanho e pressione Embaralhar para gerar operações aleatórias, ou adicione as suas.
  2. Selecione Enqueue ou Dequeue, informe o valor ao enfileirar e pressione Adicionar.
  3. Reproduza a animação ou avance passo a passo com os controles de reprodução.
  4. Acompanhe os ponteiros frente_ e final_, o contador n_ e a linha de C++ destacada.

Perguntas frequentes

O que significa FIFO?
First In, First Out: os elementos saem na mesma ordem em que chegaram, como pessoas esperando em uma fila.
Qual a diferença em relação a uma pilha?
Uma fila insere no final e remove do início, enquanto uma pilha faz ambas as coisas no topo.
O que acontece ao fazer dequeue do último elemento?
A fila fica vazia, final_ é definido como nullptr e a memória do nó é liberada.

Ferramentas relacionadas