Listas Lineares

Vimos anteriormente o conceito de listas

ALGESD 07 lineares e mostramos que tanto as pilhas
Filas quanto as filas são listas lineares restritas;

Vimos que as pilhas caracterizam-se pela
dinâmica em que o último elemento que
Prof. Dr. Marcelo Duduchi
entra é o primeiro a sair;

Conheceremos agora as filas...
Filas Filas (modelo conceitual)

Uma lista linear onde a entrada é feita por uma
Store Retrieve
extremidade e a saída é feita pela outra
extremidade é conhecida como fila;

Neste caso o primeiro elemento a entrar é o
primeiro elemento a sair (First In First Out);

Existem duas funções que se aplicam a todas
as filas:
 STORE, que insere um dado no final da fila;
 RETRIEVE, que remove o item do início da fila;
Filas (representação gráfica) Filas (representação gráfica)
Filas (implementação) Filas (implementação)

Estaremos optando por
implementar uma fila circular
Na Inclusão colocamos o elemento na
que é mais eficiente que a fila
onde “empurramos” os posição do rear e ele vai para a próxima
elementos para as posições posição; front front
iniciais do vetor;

Na fila circular tanto o front A A
quanto o rear caminham em 8 1 8 1
B B
direção ao final do vetor porém, 7 2 7 2
ao chegar no final consideramos 6 3
rear
6 3 C
5 4 5 4
que voltamos ao início dele de
forma “circular”; C rear
store (“C”,fl);
Filas (implementação) Filas (implementação)

A condição de fila vazia

Na retirada retornamos o elemento que acontece quando front é igual a
está no front e ele vai para a próxima rear;
posição; front
A condição de fila cheia
A acontece quando o “próximo de
A front rear” for igual a front
8 1 8 1
7 2
B
7 2
B
Uma das possíveis saídas para
6 3 C 6 3 C fila cheia ser diferente de fila
5 4 5 4 vazia;

Por conta disto um elemento
rear rear
do vetor é “sacrificado”;
retrieve (fl);
Filas (implementação) Filas (Dados e construtores)
public class FilaChar {

Consideremos para a nossa implementação um private int tamanho, front, rear;
private char vet[];
grupo de operações:
FilaChar(){
 NEXT: indica quem é o próximo elemento; tamanho = 5;
vet = new char[5];
 ISEMPTY: verifica se está vazia; front = 0;
rear = 0;
 ISFULL: verifica se está cheia; }
 STORE: coloca um elemento;
FilaChar(int n) {
 RETRIEVE: retira um elemento; tamanho = n;
vet = new char[tamanho];
 DESTROY: retira todos os elementos; front = 0;
rear = 0;
}
...
Filas (Next) Filas (Isfull e Store)
... int next(int n) { ... boolean isfull(){
if(n == tamanho-1) if (next(rear) == front)
return 0; return true;
else
else return false;
return n+1; }
}
void store(char elem){
... if(isfull()){
System.out.println("Overflow!");
System.exit(1);
A rotina Next é a responsável por controlar quem }
é o próximo tanto para rear quanto para front; else
vet[rear]=elem;
Pode ser substituída por: (n+1)%(tamanho); rear = next(rear);
} ...
Filas (Isempty e Retrieve) Filas (destroy)
... boolean isempty(){
if (rear == front)
...
return true;
else void destroy(){
return false;
} front = rear;
char retrieve(){ }
if(isempty()){
System.out.println("Underflow!");
System.exit(1); }
//return '*';
}
//else
char aux = vet[front];
front = next(front);
return aux;
} ...
Filas (exemplo de utilização 1) Filas (exemplo de utilização 2)
public static void main(String[] args) { public static void main(String[] args) {
System.out.println("criando fila com 10 elementos...");
FilaChar f1 = new FilaChar(10); System.out.println("criando string ESTRUTURA...");
System.out.println("verificando status inicial da fila..."); String palavra="FILA";
System.out.println("está vazia? "+f1.isempty()); System.out.println("criando uma fila com tamanho do string...");
System.out.println("está cheia? "+f1.isfull()); FilaChar f2 = new FilaChar(palavra.length()+1);
System.out.println("incluindo o caractere A..."); System.out.println("incluindo os caracteres do string na fila...");
f1.store('A'); char aux;
for(int i=0;i<palavra.length();i++){
System.out.println("verificando status da fila..."); aux=palavra.charAt(i);
System.out.println("está vazia? "+f1.isempty()); f2.store(aux);
System.out.println("está cheia? "+f1.isfull()); }
System.out.println("incluindo o caractere B..."); System.out.println("verificando status da fila...");
f1.store('B'); System.out.println("está vazia? "+f2.isempty());
System.out.println("incluindo o caractere C..."); System.out.println("está cheia? "+f2.isfull());
f1.store('C'); System.out.println("retirando chars da fila até esvaziar...");
System.out.println("realizando 3 retrieves na seqüência..."); while(f2.isempty()==false)
System.out.print(f2.retrieve());
System.out.println(f1.retrieve()); System.out.println("");
System.out.println(f1.retrieve()); System.out.println("verificando status da fila...");
System.out.println(f1.retrieve()); System.out.println("está vazia? "+f2.isempty());
System.out.println("verificando status da fila..."); System.out.println("está cheia? "+f2.isfull());
System.out.println("está vazia? "+f1.isempty()); }
System.out.println("está cheia? "+f1.isfull());
}
Filas (aplicações)

Todo buffer funciona como uma fila pois
os primeiros caracteres que vão para o
buffer são os primeiros a sair;

As filas também são bastante usadas para
a simulação de filas de espera do mundo
real como caixas em banco, etc.

Uma aplicação interessante de filas é a
coloração de regiões.