Anda di halaman 1dari 10

 


  

1. Filas
Uma Fila é uma estrutura de dados do tipo FIFO (First In First Out), cujo funcionamento é
inspirado no de uma fila “natural”, na qual o primeiro elemento a ser inserido é sempre o
primeiro elemento a ser retirado. Um exemplo de uma fila é o caso de uma “fila de
supermercado”.

1.1. Método

A implementação de uma fila como um “tipo abstracto de dados”, permite a definição


abstracta dos aspectos essenciais de comportamento e funcionamento de um objecto sem
definição de quai quer aspectos de implementação. Uma fila tem por norma as seguintes
funcionalidade:
Colocar e retirar dados da fila.
*
add – guardar um elemento na fila
*
remove – retirar um elemento da fil
*
top – retornar o elemento do topo da fila
Testar se a fila está vazia ou cheia.
*
full – Verificar se a fila está cheia (não pode guardar mais elementos).
*
empty – Verificar se a fila está vazia (não contém elementos)
Inicializar ou limpar:
*
construct – Colocar a fila num estado “pronto” a ser utilizada
A implementação de uma fila pode ser efectuada através da utilização de diferentes
estruturas de dados (vectores, listas ligadas, árvores, etc.). De seguida, apresenta-se duas
implementação de uma fila através da utilização de vectores e listas ligadas.

Características das filas:


+ Os dados são armazenados pela ordem de entrada

Tipos de filas:
+ Filas de espera (queues)
o com duplo fim (deque “double-ended queue)
+ Filas de espera com prioridades (priority queues)

Implementação das filas:


+ usando vectores / arrays (circulares ou não)
+ utilizando um apontador para nós de informação (lista ligada)

   !" #$%&!'' ()


1 de 10
,-. /0 1 2 3434 5

2. Filas de espera
2.1. Implementação em C++ usando arrays
2.1.1. Fila usando arrays
Vantagens:
B
Facilidade de implementação.

Desvantagens:
B
Vectores possuem um espaço limitado para armazenamento de dados.
B
Necessidade de definir um espaço grande o suficiente para a fila.
B
Necessidade de um indicador para o inicio e para o fim da fila.

Método de Implementação:
B
A adição de elementos à fila resulta no incremento do indicador do fim da fila
B
A remoção de elementos da fila resulta no incremento do indicador do inicio da
fila
Logicamente, assim, obtém-se rapidamente falta de espaço na fila para a inserção de
mais elementos! Solução?

Soluções comuns:
B
Juntar os elementos sempre à esquerda, cada vez que se faz u a remoção! (NÃO)
B
“Imaginar” o array como sendo um array circular, isto é, unir o fim do array ao
inicio da array! (Melhor Implementação)

2.1.2. Fila usando “array circular”

0 1 2 3 4 5 6 7 8 9

Estruturas de dados necessárias:


B
Indicador do in cio da fila “inicio”
B
Indicar do fim da fila fim”
B
Espaço para armazenar os elementos da fila dados“
B
Quantidade máxima de elementos da fila MAXFILA”

Depois de estabelecido as necessidades estruturas de dados para a sua implementação,


apresenta-se o modo de funcionamento:
B
Inicialmente a fila encontra-se vazia, o que quer dizer que:
B
inicio = = 0
B
fim = = 0

6-783/84709 4: ;<8";/ =$/>?<@@ :A8-)7/


2 de 10
CDE FG H I JKJK L

Isto é, a fila encontra-se vazia quando inicio == fim


Y
Depois de adicionar e remover alguns elementos (ex.: adicionar 10, remover 2,
Y
adicionar 2 elementos), a fila encontra-se cheia, donde obtém-se que:
Y Inicio = = 2 (10 + 2, porque temos uma lista circular)
Fim = = 2 (número de elementos removidos)
Isto é, a fila encontra-se cheia quando inicio == fim

PROBLEMA: Como distinguir entre fila cheia e fila vazia????

Y
Soluções comuns:
Manter sempre uma posição vazia no array entre o indicador de inicio e o
indicador de fim, obrigando a definir uma capacidade de MAXFILA+1” para se
Y obter uma capacidade de MAXFILA”
Definir um indicador do número de elementos que a fila conté

2.1.3. Fila usando “array circular” com posição vazia entre inicio e fim

//file name : fila.hpp


#ifndef FILA
#define FILA
class FILA
{
public:
FILA();
~FILA();
bool add(int elemento); // inserir um elemento
int remove(); // remover um elemento
bool empty(); // lista vazia?
bool full(); // lista cheia?
int inicio(); // retornar o inico da fila (não retira elemento)
private:
const int MAXFILA = 100;
int inicio; // indica o n.º de elementos da fila
int fim;
int dados[MAXFILA];
};
#endif

//file name: fila.cpp


FILA::FILA()
{
inicio = 0;
fim = 0; // Inicio == Fim da fila
}

FILA::~FILA()
{ }

MDNOJFOKNGP KQ RSO"RF T$FUVSWW QXOD)NF


3 de 10
Z[\ ]^ _ ` abab c

bool FILA::empty()
{
return(inicio == fim);
}

bool FILA::full()
{
return( inicio == ((fim +1) % MAXFILA) );
}

bool FILA::add(int elemento)


{
if ( full() )
{
erro = 1; // erro: fila cheia
return(false);
}
else
{
dados[fim] = elemento;
fim = (fim + 1) % MAXFILA;
return(true);
}
}

int FILA::remove()
{ int valor;
if ( empty() )
{
erro = 2; // erro: fila vazia
return(-1);
}
else
{
valor = dados[fim];
inicio = (inicio + 1) % MAXFILA;
}
return(valor);
}

int FILA::top()
{
if ( empty() )
{
erro = 2; // erro: fila vazia
return(-1);
}
else
{
return(dados[inicio]);
}
}

d[efa]fbe^g bh ijf"i] k$]lmjnn hof[)e]


4 de 10
pqr st u v wxwx y

2.2. Implementação em C++ usando listas ligadas

2.2.1. Fila usando Listas Ligadas


Vantagens:
†
Não existe número máximo de elementos a armazenar (só limitado pelo espaço da
memória do computador).
†
O espaço de memória utilizado é alojado de forma dinâmica, sendo só utilizado o
espaço necessário para armazenar os valores guardados na fila.

Desvantagens:
†
A implementação é fácil, contudo mais difícil que na utilização de vectores.

Método de Implementação:
†
Fila Vazia: Lista Ligada sem elementos
†
Fila Cheia:
†
Adição de elementos: consiste na adição de um elemento no fim da Lista Ligada.
†
Remoção de elementos: consiste em remover um elemento no início da Lista
Ligada.

//file name: fila.hpp


#define NULL 0

class FILA
{
public:
FILA();
~FILA();
bool add(int elemento); // inserir um elemento
int remove(); // remover um elemento
bool empty(); // lista vazia?
bool full(); // lista cheia?
private:
struct no
{
int dados:
struct no * next;
};
struct no * inicio;
};

//file name: fila.cpp


FILA::FILA()
{
inicio = NULL;
}

zq{|ws|x{t} x~ €|"s $s‚ƒ€„„ ~…|q){s


5 de 10
‡ˆ‰ Š‹ Œ  ŽŽ 

FILA::~FILA()
{
int valor;

while (! empty() )
{ valor = remove(); }
}

bool FILA::add(int elemento)


{
struct no *apt;
if ((apt = new no) ==NULL)
{ // cout << "Erro: Memoria esgotada!\n";
return(false);
}
apt->valor=elemento;
apt->next = inicio;
inicio = apt;
return(true);
}

int FILA::remove()
{ int valor;
struct no *apt;

if (empty()==true)
{return(0);}
else
{
valor = inicio->valor;
apt = inicio->next;
delete inicio;
inicio = apt;
return(valor);
}
}

bool FILA::empty()
{
return(inicio==NULL);
}

2.3. Fila - Compilação “C++”



Invocação do compilador:
g++ -wall -g -o <executável> arq1.c arq2.c … arqN.c

Parâmetros:
-g indicar ao compilador para gerar código para o debuger
-o nome do arquivo executável que será gerado
-wall indicar todos os erros e avisos

‘ˆ’“ŽŠ“’‹” • –—“"–Š ˜$Š™š—›› •œ“ˆ)’Š


6 de 10
žŸ  ¡¢ £ ¤ ¥¦¥¦ §

2.4. Fila definida na STL (Standard Template Library)

Uma fila é um modelo de um contentor, que provê um subconjunto restringido de


funcionalidade de um CONTENTOR: provê inserção, remoção, e inspecção do elemento ao
topo da fila.
Fila é um modelo de um contentor, que é implementado com base num tipo de contentor da
STL, sendo por omissão baseado no contentor “deque” da STL, podendo contudo, ser
utilizado outro contentor explicitamente.

2.4.1. Exemplo de utilização da classe QUEUE


#include <queue> // QUEUE of Standard Type Library
void main()
{
queue<int> q; // igual a: queue<int, deque<int>>
q.push(8); //guardar elemento 8
q.push(7);
q.push(4);

// verificar o número de elementos da fila


assert( q.size() == 3);
// verificar se o inicio da fila contém o elemento n.º 8
assert( q.front() ==8);
// verificar se o fim da fila contém o elemento n.º 4
assert( q.back() == 4);

// verificar se o 1º elemento a ser retirado é o n.º 8?


assert( q.pop() == 8);
assert( q.empty()); // verificar se a fila está vazia
}

¨Ÿ©ª¥¡ª¦©¢« ¦¬ ­®ª"­¡ ¯$¡°±®²² ¬³ªŸ)©¡


7 de 10
´µ¶ ·¸ ¹ º »¼»¼ ½

2.5. Exemplos do uso de Filas


EXEMPLO I: Uma “fila de impressão” (print queue) é uma lista de documentos que
esperam para serem imprimidos na impressora, na qual os documentos são impressos
segundo a ordem de chegada à lista.
Os documentos são enviados para a “fila de impressão” pelas diversas aplicações,
restando ao programa de impressão o processo de retirar os documentos da fila e enviá-
los para a impressora.

Programa para “fila de impressão”


Algoritmo:
//Recebe: Documento para ser impresso na impressora.
O Sistema Operativo cria uma Fila vazia para guardar os documentos a serem impressos.
1. Enquanto a Fila não está vazia
a. Retirar um documento da Fil
b. e escrevê-lo na impressora
2. voltar ao passo 1.

EXEMPLO II: Verificar se uma palavra é uma palíndromo/capicua*

*
Dicionário da Língua Portugue sa da Porto Editora: capicua = conjunto de algarismos ou
letras, cuja leitura é a mesma quando feita nos dois sentidos (lido de trás para diante ou
de diante para trás)
¾µ¿À»·À¼¿¸Á ¼Â ÃÄÀ"÷ Å$·ÆÇÄÈÈ ÂÉÀµ)¿·
8 de 10
ÊËÌ ÍÎ Ï Ð ÑÒÑÒ Ó

3. Filas de espera com prioridades

Filas de espera com prioridades, são filas na qual a ordem de armazenamento na fila não segue a
ordem de inserção (temporal), mas sim segundo um campo de prioridade.

Qualquer implementação de uma fila de espera pode ser modificada de modo a adquirir as
características de uma fila de espera com prioridades.

A implementação de uma fila de espera pode ser alterada de modo, a que a inserção sej
efectuada segundo o campo de prioridad es, não sendo necessário mais alterações à sua
implementação.

Implementação das filas:


à
usando vectores / arrays (circulares ou não), requer a junção dos elementos sempre à
esquerda, cada vez que se faz uma inserção! (NÃO!!!)
à
utilizando uma implementação de Lista Ligada! (preferível !!!)

ÔËÕÖÑÍÖÒÕÎ× ÒØ ÙÚÖ"ÙÍ Û$ÍÜÝÚÞÞ ØßÖË)ÕÍ


9 de 10
áâã äå æ ç èéèé ê

3.1. Fila de espera com prioridade definida na STL

Uma fila é um modelo de um contentor, que provê um subconjunto restringido de


funcionalidade de um CONTENTOR: provê inserção, remoção, e inspecção do elemento ao
topo da fila.
Fila é um modelo de um contentor, que é implementado com base num tipo de contentor da
STL, sendo por omissão baseado no contentor “vecto ” da STL, podendo contudo, ser
utilizado outro contentor explicitamente.

3.1.1. Exemplo de utilização da classe QUEUE


#include <queue> // QUEUE of Standard Type Library
int main() {
priority_queue<int> q;
// igual a: priority_queue<int, vector<int>>
q.push(1); //guardar elemento 1
q.push(4);
q.push(8);
q.push(7);
// verificar o número de elementos da fila
assert(q.size() == 4);
// verificar se o inicio da fila contém o elemento n.º 8
assert(q.top() == 8);
q.pop();
assert(q.top() == 7);
assert(q.empty());// verificar se a fila está vazia
return (0);
}

4. Resumo
Uma Fila é um (ADT - Abstract Data Type) tipo abstracto de dados, na qual são
conhecidas os aspectos essenciais de comportamento e funcionamento de um objecto sem
qualquer relação com a estrutura interna do objecto, e a forma como este é implementado.

ëâìíèäíéìåî éï ðñí"ðä ò$äóôñõõ ïöíâ)ìä


10 de 10