(2) Faça um programa que armazena um conjunto de valores inteiros em uma fila (queue). O valor -1 indica o final da leitura.
Faça uma função inverterFila que recebe como parâmetro a fila e inverte os elementos dessa fila, usando uma pilha como estrutura auxiliar.
Faça uma função imprimirFila, que recebe uma fila como parâmetro e imprime seus elementos, indicando quem é o elemento da frente e o de trás. Chame a função imprimirFila antes e depois da chamada da função inverterFila.
Exemplo de entrada:
Digite os elementos da fila(-1 para encerrar):
1
5
3
7
0
-1

Exemplo de saída:

Elementos da fila:
Frente: 1
Trás: 0
15370
Inversão:
Elementos da fila:
Frente: 1
Trás: 0
07351

Passo 1

Beleza, o enunciado pede um programinha que:
  1. Lê uma sequência de inteiros e guarda numa fila até encontrar o valor −1 (que não entra na fila).
  2. Tem uma função inverterFila que usa uma pilha auxiliar pra inverter a ordem dos elementos da fila.
  3. Tem uma função imprimirFila que mostra quem tá na frente, quem tá atrás e imprime todos os elementos (no nosso exemplo concatenados).
    Conteúdo: estruturas de dados (fila FIFO e pilha LIFO) e manipulação básica de filas/pilhas. A gente vai precisar entender operações de fila (enqueue, dequeue, front, back) e de pilha (push, pop).

Passo 2

Vamos ler os números e enfileirar:
  • Explicação teórica: fila (queue) é FIFO, “first in, first out” — o primeiro que entra é o primeiro que sai.
  • Operações básicas:
    • enqueue(x): coloca x no final da fila.
    • dequeue(): remove o elemento da frente.
    • front(): lê o elemento da frente sem remover.
    • back(): lê o elemento de trás sem remover.
Leitura passo a passo (pseudocódigo):
fila Q ← vazia  
enquanto true:
    leia x
    se x == -1 então
        pare o loop
    fimSe
    enqueue(Q, x)
fimEnquanto

Passo 3

Agora, a função imprimirFila(Q):
  1. Queremos exibir “Frente: …” e “Trás: …”. Usamos front(Q) e back(Q).
  2. Depois, mostramos todos os elementos na ordem da fila.
Como não queremos perder a fila original, podemos copiar Q para uma fila auxiliar temp e ir desempilhando dela:
função imprimirFila(Q):
    se Q estiver vazia então
        escreva "Fila vazia"
        retorne
    fimSe
    escreva "Frente: ", front(Q)
    escreva "Trás: ", back(Q)
    // pra imprimir todos
    temp ← cópia de Q
    enquanto temp não estiver vazia:
        escreva dequeue(temp) sem pular linha
    fimEnquanto
    escreva nova linha
fimFunção

Passo 4

A função inverterFila(Q) usa uma pilha S como auxiliar:
  • Pilha (stack) é LIFO, “last in, first out” — o último que entra é o primeiro que sai.
  • Operações: push(S, x) e pop(S) retornando o topo.
Para inverter, a lógica é:
  1. Enquanto a fila não estiver vazia, vamos dequeue e push esses valores na pilha. Isso faz o maior virar fundo da pilha.
  2. Depois, enquanto a pilha não estiver vazia, damos pop e enqueue de volta na fila. Isso coloca os elementos em ordem invertida.
função inverterFila(Q):
    S ← pilha vazia
    // Passo 1: esvaziar fila pra pilha
    enquanto Q não estiver vazia:
        x ← dequeue(Q)
        push(S, x)
    fimEnquanto
    // Passo 2: voltar da pilha pra fila
    enquanto S não estiver vazia:
        x ← pop(S)
        enqueue(Q, x)
    fimEnquanto
fimFunção

Passo 5

Juntando tudo no main:
programa principal:
    // 1) Ler e enfileirar
    Q ← fila vazia
    leia e enqueue até -1 (como no Passo 2)

    // 2) Imprimir antes
    escreva "Elementos da fila:"
    imprimirFila(Q)

    // 3) Inverter
    escreva "Inversão:"
    inverterFila(Q)

    // 4) Imprimir depois
    escreva "Elementos da fila:"
    imprimirFila(Q)
fimPrograma

Resposta

Segue o pseudocódigo completo em LaTeX (as operações básicas ficam em texto normal):
l bfprograma principal: Q fila vazia enquanto verdadeiro: <=ia x se x = -1 então pare enqueue(Q,x) fim enquanto escreva "E<=mentos da fila:" imprimirFila(Q) escreva "Inversão:" inverterFila(Q) escreva "E<=mentos da fila:" imprimirFila(Q) bffim programa bffunção imprimirFila(Q): se Q vazia então escreva "Fila vazia" return fim se escreva "Frente: ", front(Q) escreva "Trás: ", back(Q) temp cópia de Q enquanto temp não vazia: escreva dequeue(temp) sem pular linha fim enquanto escreva nova linha bffim função bffunção inverterFila(Q): S pilha vazia enquanto Q não vazia: x dequeue(Q) push(S,x) fim enquanto enquanto S não vazia: x pop(S) enqueue(Q,x) fim enquanto bffim função ããçããáóãçãçãããçã

Exercícios relacionados