UNIVERSIDADE S.

TOMÁS DE MOÇAMBIQUE
CURSO DE TECNOLOGIAS DE SISTEMAS DE
INFORMAÇÃO
Estrutura de Dados e Algoritmos
Ano 2007

Aula 7: Filas

Conteúdo

1. Conceito
2. Operações
3. Implementação
4. Exercícios práticos

1
1. Conceito

A fila é uma lista linear em que todas as inserções de novos elementos são realizadas
numa extremidade da lista e todas as remoções de elementos são feitas na outra
extremidade da lista.

Fila é uma estrutura de dados simples, linear e de acesso sequencial, porém, diferente da
pilha. Esta, pode ser manipulada por 2 extremidades conhecidas como “cauda” (por onde
é feita a inserção de elementos na fila) e “frente” (por onde é possível remover-se os
elementos). Tal restrição define uma prioridade para a remoção de elementos, de tal
forma que o primeiro elemento a ser inserido na fila, será o primeiro a ser removido. Por
causa disso a fila é conhecida como uma estrutura FIFO – First In First Out.

Um exemplo do nosso quotidiano é a fila em caixas automáticas de bancos onde temos

uma certa ordem em que o primeiro elemento a chegar é o primeiro a dirigir-se à ATM e
consequentemente, o primeiro a sair, e quem chega por último, segue o até então último
elemento da fila, sendo portanto, o último a ser servido e consequentemente o último a
sair.

Representação de uma Fila

Dependendo da implementação escolhida, podemos representar a fila de duas formas:

representação sequencial e representação ligada.

Na representação sequencial usa-se um array, o que faz com que a capacidade da fila seja
fixa, enquanto que na representação ligada, usa-se lista simples.

2
Representação Sequencial de Fila

Representação Ligada de Fila

2. Operações sobre Filas

Tal como na pilha, temos nesta estrutura de dados duas operações básicas que são
enqueue (permite inserir um novo elemento na cauda da fila) e dequeue (permite
remover o elemento que esta na frente da fila).

Operações Associadas:

1) Verificar se a fila está ou não vazia. empty()

2) Inserir um novo elemento na fila. enqueue()
3) Remover o elemento que está na frente da fila. dequeue()

3
 4) Devolver o tamanho da fila. getSize()
5) Mostrar o conteúdo da fila. print()

3. Implementação da Fila

A fila pode ser implementada de duas maneiras: a primeira é usando a estrutura estática
Array e a outra é fazendo o uso da estrutura dinâmica lista.

3.1 Implementação usando Array

Na implementação de fila usando a estrutura estática, um Array deve ser definido para
representá-la.

public class SequentialQueue {

Object Q[];
int size; //capacidade da fila
int front = 0; //frente com valor inicial 0
int rear = 0; //cauda com valor inicial 0

//Cria a fila
public SequentialQueue (){
Q = new Object[size];
}
… … … … …
… … … … …

1) Verificar se a fila está ou não vazia. empty()

A fila está vazia se frente = cauda

//verifica se a fila esta vazia

public boolean empty(){
return front == rear;
}

4
2) Inserir um novo elemento na fila. enqueue()

//insere novo elemento no fim da fila

public void enqueue(Object item) {
Q[rear] = item;
rear++;
}

3) Remover o elemento que está na frente da fila. dequeue()

//remove um elemento da fila

public Object dequeue(){
Object x = Q[front];
Front++;
return x;
}

4) Devolver o tamanho da fila. getSize()

Tamanho da fila é a diferença: frente - cauda

//retorna o tamanho da fila

public int getSize(){
return (rear – front);
}

5) Mostrar o conteúdo da fila. print()

Deve percorrer o array da frente até a cauda e a cada indice imprimir o valor.

//mostra o conteúdo da fila

Public void print(){
for (int i = front; i < rear; i++){
System.out.println(Q[i]);
}
}

5
3.2 Implementação usando Lista Ligada
Na implementação de fila usando a estrutura dinâmica, uma lista deve ser definida para
representá-la.

private class Node {

Object item;
Node next;

//constructor
public Node(Object anItem){
item = anItem;
next = null;
}

//métodos de acesso
public Object getItem(){
return item;
}
public void setItem(Object anItem){
item = anItem;
}
public Node getNext(){
return next;
}

public void setNext(Node theNext){

next = theNext;
}

public class LinkedQueue {

Node front;
Node rear;
int count;

//cria uma lista vazia

public LinkedQueue()
{
front = null;
rear = null;
count = 0;
}
… … … … …

6
1) Verificar se a fila está ou não vazia. empty()
A fila está vazia se front = null

//verifica se a fila está vazia

public boolean empty()
{
return front == null;
}

2) Inserir um novo elemento na fila. enqueue()

//insere novo elemento na fila

public void enqueue(Object item)
{
Node newNode = new Node(item);
if (rear == null)
{
front = newNode;
rear = newNode;
}
else
{
rear.setNext(newNode);
rear = newNode;
}
count++;
}

7
3) Remover o elemento que está na frente da fila. dequeue()

public Object dequeue()

{
if (front == null)
return null;
else
{
Node temp = front;
front = front.getNext();
if (front == null)
rear = null;
count--;
return temp.getItem();
}
}

4) Devolver o tamanho da fila. getSize()

public int getSize()
{
return count;
}

8
5) Mostrar o conteúdo da fila. print()

public void print()

{
Node temp = front;
do
{
System.out.println(temp.getItem());
temp = temp.getNext();
} while (temp != null)

9
 5. Exercícios

1) Considere uma implementação de uma fila de forma sequencial do tipo inteiro.

1.1 Implemente o método da classe Fila que insira um elemento da fila.
1.2 Implemente o método que remova um elemento Z da fila que se situa na
segunda posição da fila.
1.3 Implmente o método que devolva a média dos primeiros 3 elementos da fila.

2) Suponha que uma fila é implementada de forma ligada com elementos do seguinte
tipo:

public Estudante
{
String nome;
int nota;
Estudante next;
}

2.1 Implemente o método que permita a construção da FilaLigada.

2.2 Implemente o método que remova um elemento na fila.
2.3 Implemente o método que devolva o estudante com a maior nota da turma.

________________________________________________________________________
Docentes regentes:
Rossana Abdul Carimo
Hamilton Isaias Mutaquiha

10