Filas Denise Guliato Faculdade de Computação – UFU guliato Vários slides foram adaptados de...
Transcript of Filas Denise Guliato Faculdade de Computação – UFU guliato Vários slides foram adaptados de...
FilasFilas
Denise GuliatoFaculdade de Computação – UFUwww.facom.ufu.br/~guliato
Vários slides foram adaptados de Nina Edelwais e Renata GalanteEstrutura de Dados – Série de Livros Didáticos - Informática - UFRGS
Pilhas e filasPilhas e filas
FilasFilas
FilasFilas
Operações válidas:Operações válidas:
• Criar uma fila vazia• Inserir um nodo no final da fila• Excluir o nodo do início da fila• Consultar• Destruir a fila
InserçõesExclusões
eConsultas
FinalInício
Filas
TAD FilaTAD Fila
Dados: numeros inteiros
Operações:E_cheia entrada: o endereço da fila processo: verifica se a fila esta na condição de
cheia saida: 1 se cheia, 0 caso contrário
TAD FilaTAD Fila
E_vazia entrada: o endereço da fila processo: verifica se a fila está na condição de
vazia saida: 1 se vazia, 0 caso contrario
TAD FilaTAD Fila
Cria_fila entrada: nenhuma processo: aloca área para a fila e a coloca na
condição de vazia saida: endereço da fila
TAD FilaTAD Fila
Insere_fila entrada: endereço da fila e o elemento processo: insere elemento no final da fila e
atualiza a fila saida: endereço da fila
TAD FilaTAD Fila
Remove_fila entrada: endereço da fila, endereço da
variável que contém a informação do nodo removido
processo: remove elemento do inicio da fila e atualiza fila. Atualiza a variável de entrada.
saida: endereço da fila
TAD FilaTAD Fila
Consulta_fila entrada: o endereço da fila e o endereço da
variável que recebe o resultado da consulta; processo: consulta o inicio da fila, atualizando
a variável passada como parâmetro; saida: 1 se sucesso e 0 se fracasso (fila vazia ou
inexistente).
TAD FilaTAD Fila
Libera_fila entrada: o endereço da fila processo: libera toda area alocada para a fila saida: o endereço da fila
TAD FilaTAD Fila
Imprime_fila
Entrada: o endereço da fila
Processo: percorre a fila e imprime os elementos
Saida: 1 se sucesso; 0 se fracasso (fila inexistente)
FilasFilas
Filas Filas implementadas por implementadas por contiguidade físicacontiguidade física
IF : início da filaFF : final da filaLS : limite superior da área (MAX_FILA-1)
Fila vazia (?)Fila vazia (?)
IF = FF = 0
Inserções
ExclusõeseConsultas
Fila implementada sobre arranjoFila implementada sobre arranjo
0 1 2 3 4 5 6 7 8 9 10 12 13 14 15LS IF FF
FILA
Fila por contiguidade
Evolução da FilaEvolução da FilaFila por contiguidade
FILA
FILA
LI=IF LS
3
FILA
LI=IF LS
3 7
FF
FILA
LI=IF LS
3 7 5
FF
FILA
LI LS
7 5
FFIF
1. Inicializar a fila2. Inserir um novo nodo com valor 33. Inserir um novo nodo com valor 74. Inserir um novo nodo com valor 55. Remover um nodo
FF
LI=IF=FF
Evolução da Fila (cont.)Evolução da Fila (cont.)Fila por contiguidade
FILA 7 5
0 1 32 54
5FILA
LI LS
5 8FILA
LI LSFF
5 8 4FILA
LI FF=LS
FILA 5 8 4 1
LI LSIF
1. Inicializa a fia2. Inserir um novo nodo com valor 33. Inserir um novo nodo com valor 74. Inserir um novo nodo com valor 55. Remover um nodo6. Remover um nodo7. Inserir um novo nodo com valor 88. Inserir um novo nodo com valor 49. Inserir um novo nodo com valor 1
0 1 32 54
0 1 32 54
0 1 32 54
0 1 32 54
LI IF
FF
LS
IF
IF
FF
IF
9. Inserir um novo nodo com valor 6
E AGORA ?
LSFFIF
LI
Ocupação circular do arranjoOcupação circular do arranjo
FILA 0 1 2 3 4 5 6 7 8 9 10 12 13
0 1 2 3 4 5 6 7 8 9 10 12 13LSFFIFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 LS = FFIFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 LSIFLI ==FF
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI
FILA
Fila por contiguidade
Ocupação circular do arranjoOcupação circular do arranjo
0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF= IFLI
FILA
Ocupação circular do arranjoOcupação circular do arranjo
0 1 2 3 4 5 6 7 8 9 10 12 13LSIF = FFLI =
FILA
FILA VAZIA IF==FF
FILA CHEIA IF==FF
0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF= IFLI
FILA
COMO RESOLVER ESSE PROBLEMA??
AlgoritmoAlgoritmo: Verifica: Verifica se fila está cheia/vaziase fila está cheia/vazia
Solução 1: desperdício de um nodo
Inicialização da fila: IF = 0 e FF = 0Inserção: incrementa FF e insere IF
aponta para um nodo vazio (nodo apontado por IF será sempre vazio)
0 1 2 3 4 5 6 7 8 9 10 12 13 FF=LSIFLI
FILA
Fila cheia: se (FF+1)%MAX_FILA == IFFila vazia : se IF == FF
Tipo de dados utilizado para a fila com Tipo de dados utilizado para a fila com alocação estática para solução 1alocação estática para solução 1
struct queue { int fila[MAX_FILA]; int IF; int FF; };
typedef struct queue Fila;
AlgoritmoAlgoritmo: Verifica: Verifica se fila está cheia/vaziase fila está cheia/vazia
Solução 2: alterar o tipo de dados
Inicialização da fila: IF = 0, FF = 0 e N=0Inserção: insere em FF, atualiza FF e NFila cheia: se N == MAX_FILAFila vazia : se N == 0
struct queue { int fila[MAX_FILA]; int IF; int FF; int N; //numro de elementos na fila };
typedef struct queue Fila;
Operações sobre FilasOperações sobre Filasimplementadas por contiguidade físicaimplementadas por contiguidade física
Fila por contiguidade
• Criar uma fila vazia• Inserir um nodo no final da fila• Excluir o nodo do início da fila• Consultar nodo no inicio da fila•Liberar área alocada para a fila•Verificar se fila está cheia •Verificar se fila está vazia
Operações sobre FilasOperações sobre Filasimplementadas por contiguidade físicaimplementadas por contiguidade física
SOLUÇÃO 2SOLUÇÃO 2
Inicialização da fila: IF = 0, FF = 0 e N=0Inserção: insere em FF, atualiza FF e N
Fila cheia: se N == MAX_FILAFila vazia : se N == 0
struct queue { int fila[MAX_FILA]; int IF; int FF; int N; //numro de elementos na fila };
typedef struct queue Fila;
Algoritmo:Algoritmo: Criar Fila com alocação estáticaFila* Cria_fila(void) –solução 2Fila* Cria_fila(void) –solução 2
Fila* Cria_fila(void){ Fila *Ptf; Ptf = (Fila*) malloc(sizeof(Fila)); if (Ptf != NULL) { Ptf->IF = 0; Ptf->FF = 0; Ptf ->N = 0; } return Ptf;}
AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_cheia(Fila *Ptf) –solução 2int E_cheia(Fila *Ptf) –solução 2
int E_cheia(Fila *Ptf){ if (Ptf->N == MAX_FILA) return 1; else return 0;}
AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_vazia(Fila *Ptf) –solução 2int E_vazia(Fila *Ptf) –solução 2
int E_vazia(Fila *Ptf){ if (Ptf->N == 0) return 1; else return 0;}
0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 11 12 LS = FFIFLI
FILA
Inserção de um nodo de uma fila Inserção de um nodo de uma fila Solução 2Solução 2
Fila por contiguidade
• Nodo inserido sempre no final da fila (insere e atualiza FF)
N = 6
N = 7
Algoritmo:Algoritmo: Inserir nodo na flaFila* Insere_fila(Fila *Ptf, int elem) -solução2
Fila* Insere_fila(Fila* Ptf, int elem){ if (Ptf == NULL || Ptf->N == MAX_FILA) return Ptf;
Ptf->fila[Ptf->FF] = elem; Ptf->FF = ( Ptf->FF+1)%MAX_FILA; Ptf->N++; return Ptf;}
0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI
FILA
Remoção de um nodo de uma fila Remoção de um nodo de uma fila Solução 2Solução 2
Fila por contiguidade
• Nodo removido é sempre o do início da fila
Nodo que pode ser removidoN=6
N=5
Algoritmo:Algoritmo: Remove Remove nodo da filaFila* Remove_fila(Fila *Ptp, int *elem) –solução2
Fila* Remove_fila(Fila* Ptf, int *elem){ if (Ptf == NULL || Ptf->N == 0 ) return Ptf;
*elem = Ptf->fila[Ptf->IF]; Ptf->IF= (Ptf)->IF+1)%MAX_FILA; Ptf->N--; return Ptf;}
Algoritmo:Algoritmo: Consultar Fila implementada sobre Arranjo (solução 2)int Consulta_fila(Fila *Ptf, int *elem)
Fila por contiguidade
int Consulta_fila(Fila *Ptf, int *elem){ if (Ptf == NULL || Ptf->N == 0) return 0; *elem = (Ptf)->fila[Ptf->IF]; return 1;}
Algoritmo:Algoritmo: Liberar área alocada para a filaFila Libera_fila(Fila Ptf) Ambas as soluções
Fila *Libera_fila(Fila *Ptf){ if (Ptf == NULL) return Ptl; free(Ptf); return NULL;}
Operações sobre FilasOperações sobre Filasimplementadas por contiguidade físicaimplementadas por contiguidade física
SOLUÇÃO 1SOLUÇÃO 1
Algoritmo:Algoritmo: Criar Fila com alocação estáticaFila *Cria_fila(void)Fila *Cria_fila(void)
Fila *Cria_fila(void){ Fila Ptf; Ptf = (Fila*) malloc(sizeof(Fila)); if (Ptf != NULL) { Ptf->IF = 0; Ptf->FF = 0; } return Ptf;}
AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_cheia(Fila *Ptf) –solução 1int E_cheia(Fila *Ptf) –solução 1
int E_cheia(Fila *Ptf){ if ((Ptf->FF+1)%MAX_FILA == Ptf->IF) return 1; else return 0;}
AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_vazia(Fila *Ptf) –solução 1int E_vazia(Fila *Ptf) –solução 1
int E_vazia(Fila *Ptf){ if (Ptf->IF == Ptf->FF) return 1; else return 0;}
0 1 2 3 4 5 6 7 8 9 10 12 13 14LSFFIFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 12 13 14 LSFFIFLI
FILA
Inserção de um nodo de uma fila Inserção de um nodo de uma fila Solução 1Solução 1
Fila por contiguidade
• Nodo inserido sempre no final da fila
Algoritmo:Algoritmo: Inserir nodo na fila (solução 1)int Insere_fila(Fila Ptf, int elem)
Fila* Insere_fila(Fila* Ptf, int elem){ if ((Ptf->FF+1)%MAX_FILA) == Ptf->IF) return Ptf; Ptf->FF = (Ptf->FF+1)%MAX_FILA; Ptf->fila[Ptf->FF] = elem; return Ptf;}
0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI
FILA
0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI
FILA
Remoção de um nodo de uma fila Remoção de um nodo de uma fila Solução 1Solução 1
Fila por contiguidade
• Nodo removido é sempre o do início da fila
Nodo que pode ser removido
Algoritmo:Algoritmo: Remove Remove nodo na filaFila* Remove_fila(Fila *Ptf, int *elem) –solução1
Fila* Remove_fila(Fila* Ptf,int *elem){ if (Ptf->FF == Ptf->IF) return Ptf; // fila vazia
Ptf->IF= (Ptf->IF+1)%MAX_FILA; *elem = Ptf->fila[Ptf->IF]; return Ptf;}
Acesso à fila –solução 1Acesso à fila –solução 1Fila por contiguidade
• Só o nodo do início da fila pode ser acessado
• Acesso para consulta
?
LSFFIFLI
Nodo que pode ser acessado
Algoritmo:Algoritmo: Consultar Fila implementada sobre Arranjo (solução 1)int Consulta_fila(Fila Ptf, int *elem)
Fila por contiguidade
int Consulta_fila(Fila Ptf, int *elem){ if (Ptf->FF == Ptf->IF) return 0; // fila vazia *elem = Ptf->fila[Ptf->IF+1%MAX_FILA]; return 1;}
Algoritmo:Algoritmo: Liberar área alocada para a filaFila* Libera_fila(Fila *Ptf)
Fila* Libera_fila(Fila *Ptf){ if (Ptf == NULL) return Ptl; free(Ptf); return NULL;}
FilasFilas
Filas Filas implementadas por implementadas por encadeamentoencadeamento
InserçõesExclusões e
Consultas
FinalInicio
F1 FnF3F2
PtFila
Filas implementadas por encadeamentoFilas implementadas por encadeamentoFilas por encadeamento
Info prox
Para acessar o último nodo, é necessário percorrer toda a fila a partir do primeiro nodo
struct no{ int info; struct no* prox; };
Descritor
Prim: primeiro da filaUlt : último da fila
Filas por encadeamento com descritorFilas por encadeamento com descritorFilas por encadeamento
PtDF
Prim Ult
L1 L2 L4L3
struct desc_q{ struct no* Prim; struct no* Ult; };typedef struct desc_q Fila;
Tipo de dados para o descritor da fila:
Operações sobre FilasOperações sobre Filasimplementadas por encadeamentoimplementadas por encadeamentocom descritorcom descritor
• Criar uma fila vazia• Inserir um nodo no final da fila• Excluir o nodo do início da fila• Consultar / modificar nodo do início da fila• Destruir a fila
Filas por encadeamento
Filas por encadeamento
• Alocar o descritor da fila
• Descritor inicializado em endereços nulos • Fila vazia
Criação da fila encadeadaCriação da fila encadeada
PtDF
Prim Ult
Algoritmo:Algoritmo: Criar Fila Encadeada endereçada por descritorFila* Cria_fila(void)Fila* Cria_fila(void)
Filas por encadeamento
Fila* Cria_Fila(void){ Fila *Ptf; Ptf = (Fila*) malloc (sizeof(Fila)); if (Ptf == NULL) return NULL; Ptf->Prim = NULL; Ptf->Ult = NULL; return Ptf; }
PtDFila Prim Ult
PtDFila Prim Ult
/
PtDFila Prim Ult
Filas por encadeamento
Inserção de um nodo na fila encadeadaInserção de um nodo na fila encadeada
PtDFila Prim Ult
Algoritmo:Algoritmo:Inserir novo nodo em Fila Encadeada endereçada por descritorFila* Insere_Fila(Fila* Ptf, int elem)
Filas por encadeamento
Fila Insere_Fila(Fila* Ptf, int elem){ struct no *Pt; Pt = (struct no*) malloc (sizeof(struct no)); if (Pt == NULL) return Ptf; Pt-> info = elem; Pt->prox = NULL; if (Ptf->Ult ==NULL) //fila vazia Ptf->Prim = Pt; else Ptf->Ult->prox = Pt;
Ptf->Ult = Pt; return Ptl; }
PtDFila Prim Ult
/
PtDFila Prim Ult
/
Filas por encadeamento
Remoção de um nodo de fila encadeadaRemoção de um nodo de fila encadeada
PtDFila Prim Ult
/
PtDFila Prim Ult
Algoritmo:Algoritmo: Remover um nodo de Fila Encadeada endereçada por descritorFila* Remove_fila(Fila* Ptf, int elem)
Filas por encadeamento
Fila* Remove_fila(Fila* Ptf, int elem){ struct no*aux; if ((*Ptf) == NULL) return 0; if ((*Ptf)->Prim == NULL) return 0; // fila vazia *elem = (*Ptf)->Prim->info; aux = (*Ptf)->Prim; (*Ptf)->Prim = (*Ptf)->Prim->prox; if ((*Ptf)->Prim == NULL) (*Ptf)->Ult = NULL; free(aux); return 1;}
PtDFila Prim Ult
/??
Filas por encadeamento
Acesso a um nodo de fila encadeadaAcesso a um nodo de fila encadeada
• Só o nodo do início da fila pode ser acessado
• Acessado diretamente pelo endereço no descritor
Algoritmo:Algoritmo: Consultar Fila Encadeada endereçada por descritorint Consulta_fila(Fila *Ptf)
Filas por encadeamento
int Consulta_fila(Fila *Ptf, int *elem){ If (Ptf == NULL) return 0; if (Ptf->Prim == NULL) return 0; // fila vazia *elem = Ptf->Prim->info; return 1;}
PtDFila
/
Prim Ult
Filas por encadeamento
Destruição de fila encadeadaDestruição de fila encadeada
PtDFila Prim Ult
PtDFila = nulo
Liberar posições ocupadas pela lista
Liberar descritor
Algoritmo:Algoritmo: Destruir Fila Encadeada endereçada por descritorFila* Libera_fila(Fila *Ptf)
Filas por encadeamento
Fila* Libera_fila(Fila *Ptf){ struct no* pt; if (Ptf == NULL) return NULL; while (Ptf->Prim != NULL) { Pt = Ptf->Prim; Ptf->Prim = Ptf->Prim ->prox free(Pt); } free(Ptf); return NULL;}