Fila circular

1. Estrutura de
Dados
FILAS
Profa. Divani Barbosa Gavinier
Aula 7 – parte 2

2. FILAS
A maneira mais fácil de visualizar uma fila é pensar
em clientes alinhados, esperando por um serviço
A próxima pessoa a ser atendida é a que esperou por
mais tempo, e os que chegaram posteriormente
são colocados no fim da fila.

3.  Usa o princípio de que o primeiro que entra
é o primeiro que sai.
 First In, First Out (FIFO)
 Necessita de controle de acesso do
elementos do fim e inicio (zero)
Exemplos

4. class Fila {
private long[] itens;
private int fim;
private int tam_max;
public Fila (int n) { // construtor
itens = new long[n];
tam_max = n;
fim=0;
}
public void push(long valor) { // insere itens na fila
itens [ fim ] = valor; // insere no final
fim++;
}
// Continua ...
Implementação Fila

5. // Continuação...
public void pop() { // retira itens da fila (inicio)
for(int i = 0; i < (fim-1); i++)
itens[ i ] = itens[ i+1 ]; // caminha fila
fim--;
itens[fim] = 0;
}
public long front() { // retorna item da frente (consulta)
return itens[ 0 ];
}
public boolean empty() { // esta vazia?
return ( fim == 0 );
}
public boolean full() { // esta cheia?
return (fim == tam_max );
}
// Continua ...

6. // Continuação ...
public int size() { // retorna tamanho da fila
return fim;
}
} // fim Classe Fila
/////////////////////////////////////////////////////////////
class FilaApp {
public static void main(String[] args) {
Fila f = new Fila(4);
// O usuário deve verificar se a fila esta cheia antes
// de adicionar itens
if (!f.full()) f.push(20);
else System.out.println("ATENCAO FILA CHEIA");
if (!f.full()) f.push(40);
else System.out.println("ATENCAO FILA CHEIA");
// Continua ...

7. // Continuação ...
if (!f.full()) f.push(60);
else System.out.println("ATENCAO FILA CHEIA");
if (!f.full()) f.push(80);
else System.out.println("ATENCAO FILA CHEIA");
if (!f.full()) f.push(10);
else System.out.println("ATENCAO FILA CHEIA");
while (!f.empty()) {// Ate esvaziar (se não vazio)
System.out.print(" " + f.front()); // Mostre na tela o
// valor do inicio
f.pop(); // Retira um item da fila
}
System.out.println("n");
} // fim programa principal
} // fim classe principal FilaApp

8. 8
Fila Andando
A cada passo do
laço for:
Um a um os
elementos serão
atribuídos a posição
“anterior” na fila
i=0 i=1 i=2 i=3 i=4
i=0
public void pop() {
for (int i=0; i<(fim-1); i++)
itens[i] = itens[i+1];
fim--;
itens[fim] = 0;
}
Fila andando

9. 9
A cada passo do
laço for:
Um a um os
elementos serão
atribuídos a posição
“anterior” na fila
i=0 i=1
i=0 i=1 i=2 i=3 i=4
public void pop() {
for (int i=0; i<(fim-1); i++)
itens[i] = itens[i+1];
fim--;
itens[fim] = 0;
}
Fila Andando

10. 10
A cada passo do
laço for:
Um a um os
elementos serão
atribuídos a posição
“anterior” na fila
i=0 i=1 i=2
i=0 i=1 i=2 i=3 i=4
public void pop() {
for (int i=0; i<(fim-1); i++)
itens[i] = itens[i+1];
fim--;
itens[fim] = 0;
}
Fila Andando

11. 11
A cada passo do
laço for:
Um a um os
elementos serão
atribuídos a posição
“anterior” na fila
i=0 i=1 i=2 i=3
i=0 i=1 i=2 i=3 i=4
public void pop() {
for (int i=0; i<(fim-1); i++)
itens[i] = itens[i+1];
fim--;
itens[fim] = 0;
}
Fila Andando

12. 12
i=0 i=1 i=2 i=3
i=0 i=1 i=2 i=3 i=4
public void pop() {
for (int i=0; i<(fim-1); i++)
itens[i] = itens[i+1];
fim--;
itens[fim] = 0;
}
Esta técnica é
ineficiente, pois cada
eliminação da Fila
envolve deslocar um
a um os elementos
restantes.
Se uma Fila contiver
1000 ou 2000
elementos, cada
elemento retirado da Fila
provocará o
deslocamento de todos
os demais elementos.
Fila Andando

13. 13
i=0 i=1 i=2 i=3
i=0 i=1 i=2 i=3 i=4
public void pop() {
for (int i=0; i<(fim-1); i++)
itens[i] = itens[i+1];
fim--;
itens[fim] = 0;
}
A operação de remoção
de um item na Fila
deveria logicamente
trabalhar somente com
aquele elemento.
De maneira a fazer
permanecer os demais
elementos em suas
posições originais.
Definir o vetor como um
círculo ao invés de uma
linha reta
A solução usada para este problema é
Fila Andando

14. 14
FILA CIRCULAR
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).
Exemplo uma fila circular com 3 elementos
A B C
índices
elementos

15. 15
FILA CIRCULAR
Exemplo uma fila circular com 3 elementos
A B C D E
Inserindo 2 elementos (D, E)
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).

16. 16
FILA CIRCULAR
B C D E
Retirando 1 elemento
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).

17. 17
FILA CIRCULAR
B C D E F G
Retirando 1 elemento
Adicionando 2 elementos
(F, G)
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).

18. 18
FILA CIRCULAR
C D E F G H
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).
Retirando 1 elemento e
Adicionando mais 1 (H)

19. 19
FILA CIRCULAR
I K D E F G H
Retirando 1 elemento e
Adicionando mais 2 (I, K)
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).
Retirando 1 elemento e
Adicionando mais 1 (H)

20. 20
FILA CIRCULAR
I K D E F G H
Retirando 1 elemento e
Adicionando mais 1 (H)
Inversão das posições dos ponteiros.
Se o final do vetor já foi alcançado,
então retorna-se ao início do vetor
Neste caso, os elementos também são inseridos como numa fila reta, só que a
remoção de um elemento da fila não altera os demais elementos da fila.
Ao chegar ao final da fila, um ponteiro de controle vai imediatamente para o início da
fila novamente (se este estiver vago).
Retirando 1 elemento e
Adicionando mais 2 (I, K)

21. Classe
push (enqueue): Insere itens na fila (ao final)
pop (dequeue): Retira itens da fila (primeiro item)
front: Retorna o próximo item da fila sem retira-lo (consulta)
empty: Verifica se a fila esta vazia
full: Verifica se a fila esta cheia
size: Retorna o tamanho da fila
Métodos
Campos
Construtor
public FilaCircular(int tam) {
itens = new long[tam];
tam_max = tam;
fim = -1;
inicio = 0;
nItens = 0;
}
long[] itens;
int fim;
int tam_max;
int inicio;
int nItens;

22. FRONT
Entrada: Nenhuma
Saída: Item da frente
public long front() {
if (empty()) {
System.out.println("n >>> ATENCAO FILA VAZIA");
return 0;
}
return itens[ inicio ];
}
EMPTY e FULL
Entrada: Nenhuma
Saída: Verdadeiro ou falso
public boolean empty() { return (nItens == 0 ); }
public boolean full() { return (nItens == tam_max ); }

23. POP (dequeue)
Entrada: Nenhuma
Saída: Não tem retorno
public void pop() {
if (empty()) {
System.out.println("n >>> ATENCAO FILA VAZIA");
return;
}
inicio++;
if (inicio==tam_max) inicio=0;
nItens--;
}
Inversão da posição do inicio.
Se o final do vetor já foi
alcançado
(inicio=tam_max), então
retorna-se ao início do vetor
(inicio=0).
No laço if testa-se inicio
igual a tam_max pois inicio
incrementa antes do laço if.SIZE
Entrada: Nenhuma
Saída: Tamanho da fila
public boolean size() { return nItens; }

24. PUSH (enqueue)
Código em Java
Entrada: Valor do item a ser adicionado na fila (valor)
Saída: Não tem retorno
public void push(long valor) {
if (full()) {
System.out.println("n >>> ATENCAO FILA CHEIA");
return;
}
if (fim==tam_max-1) fim=-1;
fim++;
itens [ fim ] = valor;
nItens++;
}
Inversão da posição do fim.
Se o final do vetor já foi
alcançado (fim=tam_max-1),
então retorna-se ao início do
vetor (fim=-1).
O menos um é devido o
incremento (fim++) ser
depois do laço if

25. Implementação Fila Circular
class FilaCircular {
private long[] itens;
private int fim;
private int tam_max;
private int inicio;
private int nItens;
public FilaCircular (int tam) {
itens = new long[tam];
tam_max = tam;
fim = -1;
inicio = 0;
nItens = 0;
}
public boolean empty() { return (nItens == 0 ); }
public boolean full() { return (nItens == tam_max ); }
public int size() { return nItens; }
// Continua ...

26. // Continuação ...
public void push(long valor) {
if (full()) {
System.out.println("n >>> ATENCAO FILA CHEIA");
return;
}
if (fim == tam_max-1) fim = -1;
fim++;
itens [ fim ] = valor;
nItens++;
}
public long front() {
if (empty()) {
System.out.println("n >>> ATENCAO FILA VAZIA");
return 0;
}
return itens[ inicio ];
}
// Continua ...

27. // Continuação ...
public void pop() {
if (empty()) {
System.out.println("n >>> ATENCAO FILA VAZIA");
return;
}
inicio++;
if (inicio == tam_max) inicio = 0;
nItens--;
}
} // fim Classe FilaCircular
/////////////////////////////////////////////////////////////
class FilaCircularApp { // Classe Principal
public static void main(String[] args) {
FilaCircular fc = new FilaCircular(5);
fc.push(10); fc.push(20); fc.push(30); fc.push(40);
fc.pop(); fc.pop(); fc.pop();
fc.push(50); fc.push(60); fc.push(70);
// Continua ...

28. // Continuação ...
while (!fc.empty()) { // Ate esvaziar
System.out.print(" " + fc.front()); // Mostre na tela o
// valor do inicio
fc.pop(); // retira um item da fila
}
fc.pop(); // retira um item da fila
} // fim programa principal aplicativo Fila Circular
} // fim classe principal

29. Gráfico Big O:
Demonstra como tempos de execução são afetados pelo numero de itens

30. Tabela de Estruturas de Armazenamento de
Propósito Geral (vetor e vetor ordenado) e
Propósito Especial (pilha, fila e fila circular)
Inserção Eliminação Pesquisa
Vetor O(1) O(n) O(n)
Vetor
Ordenado
O(n) O(n) O(log n)
Pilha O(1) O(1)
Fila O(1) O(n)
Fila
Circular
O(1) O(1)

31. Quando usar o quê?
Vetores (estrutura de armazenamento de propósito geral)
Inserção Eliminação Pesquisa
Vetor O(1) O(n) O(n)
Vetor Ordenado O(n) O(n) O(log n)
 São uteis quando a quantidade de dados é previsível de antemão.
 Se a velocidade de inserção for importante use vetor não ordenado.
 Se a velocidade de pesquisa for importante use vetor ordenado
 A eliminação é sempre lenta em vetores.
 Podemos expandir vetores quando eles ficam cheios (sendo assim
eles também podem funcionar quando a quantidade de dados não é
conhecida de antemão). Porém, pode haver periodicamente uma
pausa significativa enquanto eles aumentam, isso ocorre por conta da
copia dos dados antigos para o novo espaço.

32. Pilhas (estrutura de armazenamento de propósito especial)
 São uteis quando é desejável acesso apenas ao ultimo item de dados
inserido (LIFO).
 A pilha implementada como vetor é eficiente pois o item inserido mais
recentemente é colocado no fim do vetor, onde também é fácil
eliminar.
 O estouro da capacidade da pilha como vetor pode ocorrer, mas
provavelmente não, se o vetor tiver sido razoavelmente dimensionado,
porque pilhas raramente tem quantidade enorme de dados.
 Se a pilha precisar conter muitos dados e a quantidade de dados não
puder ser prevista de antemão, uma lista encadeada seria uma opção
melhor que um vetor. Porem uma lista é ligeiramente mais lenta que
um vetor, pois usa-se alocação de memória na criação de novo Nós.
Inserção Eliminação
Pilha O(1) O(1)
Quando usar o quê?

33. Filas (estrutura de armazenamento de propósito especial)
 São uteis quando é desejável acesso apenas ao primeiro item de
dados inserido (FIFO).
 A fila circular como vetor requer programação adicional para lidar com
a situação na qual a fila circunda o vetor a partir do final. Porém a
eliminação nesse caso é realizada em tempo O(1).
 Assim como a pilha, a escolha entre uma implementação de vetor ou
lista encadeada é determinada por quão bem a quantidade de dados
possa ser prevista. Use vetor se souber quantos dados haverá, caso
contrário, use lista encadeada.
Inserção Eliminação
Fila O(1) O(n)
Fila Circular O(1) O(1)
Quando usar o quê?

34. Atividades
Exercício 1: Dada uma fila contendo os valores 3, 9,
5 e 1 (nesta ordem), descreva o conteúdo dos itens
da fila após as operações:
push(2), pop, pop, pop, push(7), pop, pop,
push(4), pop, pop, push(8), push(6), pop.
Exercício 2: Construa um programa que leia n
caracteres digitados pelo usuário, até que o mesmo
pressione a tecla “enter”, e os atribua a uma fila de
caracteres conforme forem letras maiúsculas e
minúsculas, fila 1 e fila 2, respectivamente. No final
retire o conteúdo de cada fila mostrando-os na tela.

35. Exercício 3: Considerando uma fila circular
contendo no máximo 6 elementos e os valores
11, 22, 35 e 48, descreva o resultado após a
chamada dos métodos:
size, front, pop, pop, pop, front, size,
push(56), push(68), push(7), push(8), size,
push(10).
Exercício 4: Escreva um programa que implemente uma
fila circular de registro “AgendaTel” com no máximo 26
itens.
Sendo o registro AgendaTel composto de:
Nome, Telefone e E-mail.