Questão nº 57
Questão de Tecnologia da Informação · CESGRANRIO BASA 01/2021 (nº 57)
A classe Queue a seguir é uma implementação parcial do tipo abstrato de dados Fila.
```java
import java.util.ArrayList;
public class Queue<ELM> {
private ArrayList<ELM> lst=new ArrayList<ELM>();
public boolean isEmpty() {
return lst.isEmpty();
}
public void enqueue(ELM s) {
}
public ELM dequeue() {
}
}
```
Nesse contexto, qual implementação dos métodos enqueue() e dequeue() completa a classe Queue, de modo que todos os elementos inseridos em uma fila possam ser recuperados de acordo com a propriedade FIFO?
- A```java
public void enqueue(ELM s) {
lst.add(s);
}
public ELM dequeue() {
if(!lst.isEmpty())
return lst.get(0);
else
return null;
}
``` - B```java
public void enqueue(ELM s) {
lst.add(0,s);
}
public ELM dequeue() {
if(!lst.isEmpty())
return lst.remove(lst.size()-1);
else
return null;
}
``` (alternativa correta) - C```java
public void enqueue(ELM s) {
lst.add(0,s);
}
public ELM dequeue() {
if(!lst.isEmpty())
return lst.remove(0);
else
return null;
}
``` - D```java
public void enqueue(ELM s) {
lst.add(s);
}
public ELM dequeue() {
if(!lst.isEmpty())
return lst.remove(lst.size()-1);
else
return null;
}
``` - E```java
public void enqueue(ELM s) {
lst.add(lst.size(),s);
}
public ELM dequeue() {
if(!lst.isEmpty())
return lst.remove(lst.size()-1);
else
return null;
}
```
Resposta comentada
Gabarito Alternativa B
Fila é uma estrutura onde o primeiro que entra é o primeiro que sai (FIFO, do inglês First In, First Out). Para isso, o enqueue insere no final e o dequeue remove do início.
- (A) Incorreta: O
enqueueinsere no final (correto), mas odequeueapenas lê o primeiro elemento (get(0)) sem removê-lo, então o mesmo elemento seria retornado sempre, violando o FIFO. - (B) Correta: O
enqueueinsere no índice 0 (início da lista), empurrando os antigos para o final. Odequeueremove o último elemento (lst.size()-1), que é exatamente o mais antigo da fila. Isso garante FIFO: o primeiro a entrar (último da lista) é o primeiro a sair. - (C) Incorreta: O
enqueueinsere no início (0), mas odequeueremove também do início (remove(0)). Isso removeria o elemento mais recente, invertendo a ordem (LIFO, como uma pilha), não uma fila. - (D) Incorreta: O
enqueueinsere no final (correto), mas odequeueremove do final (remove(lst.size()-1)), retirando o elemento mais recente, o que também inverte a ordem (LIFO). - (E) Incorreta: O
enqueuecomlst.add(lst.size(), s)é equivalente alst.add(s)(insere no final), mas odequeueremove do final, causando o mesmo erro da alternativa D (LIFO, não FIFO).
Armadilha da banca na alternativa A: ela parece correta porque o enqueue está certo e o dequeue usa get(0) (primeiro elemento), mas esquece do remove. O aluno que não percebe que o elemento não é retirado da lista cai na pegadinha, pois o método retorna sempre o mesmo item, nunca esvaziando a fila de fato.
Fonte: CESGRANRIO BASA 01/2021 Técnico Científico - Área de Formação: Tecnologia da Informação. Reproduzida para fins de estudo.