580 likes | 795 Views
Filas. Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato. Vários slides foram adaptados de Nina Edelwais e Renata Galante Estrutura de Dados – Série de Livros Didáticos - Informática - UFRGS. Pilhas e filas. Filas. Filas. Filas. Início. Final. Inserções.
E N D
Filas Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato Vários slides foram adaptados de Nina Edelwais e Renata Galante Estrutura de Dados – Série de Livros Didáticos - Informática - UFRGS
Pilhas e filas Filas
Filas Filas Início Final Inserções Exclusões e Consultas • 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
TAD 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 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 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 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 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 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 Fila Libera_fila entrada: o endereço da fila processo: libera toda area alocada para a fila saida: o endereço da fila
TAD Fila Imprime_fila Entrada: o endereçodafila Processo: percorre a fila e imprimeoselementos Saida: 1 se sucesso; 0 se fracasso (filainexistente)
Filas Filas implementadas por contiguidade física
Fila por contiguidade Fila implementada sobre arranjo Exclusões e Consultas Inserções IF FF LS 0 1 2 3 4 5 6 7 8 9 10 12 13 14 15 FILA IF : início da fila FF : final da fila LS : limite superior da área (MAX_FILA-1) Fila vazia (?) IF = FF = 0
Fila por contiguidade Evolução da Fila LI=IF=FF FILA LI=IF LS FF • Inicializar a fila • Inserir um novo nodo com valor 3 • Inserir um novo nodo com valor 7 • Inserir um novo nodo com valor 5 • Remover um nodo 3 FILA FF LI=IF LS 3 7 FILA LI=IF LS FF 3 7 5 FILA FF LI IF LS 7 5 FILA
Fila por contiguidade 0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 Evolução da Fila (cont.) LS IF LI 7 5 FILA • Inicializa a fia • Inserir um novo nodo com valor 3 • Inserir um novo nodo com valor 7 • Inserir um novo nodo com valor 5 • Remover um nodo • Remover um nodo • Inserir um novo nodo com valor 8 • Inserir um novo nodo com valor 4 • Inserir um novo nodo com valor 1 LI IF FF LS 5 FILA FF LI LS IF 5 8 FILA IF LI FF=LS 5 8 4 FILA FF LI IF LS 9. Inserir um novo nodo com valor 6 8 4 1 5 FILA E AGORA ?
Fila por contiguidade Ocupação circular do arranjo IF LI LS FF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA LI LS FF IF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA LI IF LS = FF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA LS LI ==FF IF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA LI LS FF IF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA
Ocupação circular do arranjo LI LI LI LI LS LS LS LS FF FF FF IF IF = IF IF FF 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 13 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 13 FILA FILA FILA FILA
Ocupação circular do arranjo FILA VAZIA IF==FF LS LI = IF = FF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA FILA CHEIA IF==FF LI LS FF = IF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA COMO RESOLVER ESSE PROBLEMA??
Algoritmo: Verificase fila está cheia/vazia Solução 1: desperdício de um nodo Inicialização da fila: IF = 0 e FF = 0 Inserção: incrementa FF e insere IF aponta para um nodo vazio (nodo apontado por IF será sempre vazio) FF=LS LI IF 0 1 2 3 4 5 6 7 8 9 10 12 13 FILA Fila cheia: se (FF+1)%MAX_FILA == IF Fila vazia : se IF == FF
Tipo de dados utilizado para a fila com alocação estática para solução 1 struct queue { int fila[MAX_FILA]; int IF; int FF; }; typedef struct queue Fila;
Algoritmo: Verificase fila está cheia/vazia Solução 2: alterar o tipo de dados Inicialização da fila: IF = 0, FF = 0 e N=0 Inserção: insere em FF, atualiza FF e N struct queue { int fila[MAX_FILA]; int IF; int FF; int N; //numro de elementos na fila }; typedef struct queue Fila; Fila cheia: se N == MAX_FILA Fila vazia : se N == 0
Fila por contiguidade Operações sobre Filas implementadas por contiguidade física • 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 Filas implementadas por contiguidade física SOLUÇÃO 2
struct queue { int fila[MAX_FILA]; int IF; int FF; int N; //numro de elementos na fila }; typedef struct queue Fila; Inicialização da fila: IF = 0, FF = 0 e N=0 Inserção: insere em FF, atualiza FF e N Fila cheia: se N == MAX_FILA Fila vazia : se N == 0
Algoritmo:Criar Fila comalocação estáticaFila* 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; }
Algoritmo: Verifica se fila está cheiaint E_cheia(Fila *Ptf) –solução 2 int E_cheia(Fila *Ptf) { if (Ptf->N == MAX_FILA) return 1; else return 0; }
Algoritmo: Verifica se fila está cheiaint E_vazia(Fila *Ptf) –solução 2 int E_vazia(Fila *Ptf) { if (Ptf->N == 0) return 1; else return 0; }
Fila por contiguidade Inserção de um nodo de uma fila Solução 2 • Nodo inserido sempre no final da fila (insere e atualiza FF) N = 6 IF FF LS LI 0 1 2 3 4 5 6 7 8 9 10 11 12 FILA IF = FF LI LS 0 1 2 3 4 5 6 7 8 9 10 11 12 FILA N = 7
Algoritmo:Inserir nodo naflaFila*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; }
Fila por contiguidade Remoção de um nodo de uma fila Solução 2 • Nodo removido é sempre o do início da fila Nodo que pode ser removido N=6 IF LI LS FF 0 1 2 3 4 5 6 7 8 9 10 11 12 FILA FF IF LI LS 0 1 2 3 4 5 6 7 8 9 10 11 12 FILA N=5
Algoritmo: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; }
Fila por contiguidade Algoritmo:Consultar Fila implementada sobre Arranjo (solução 2) int Consulta_fila(Fila *Ptf, int *elem) int Consulta_fila(Fila *Ptf, int *elem) { if (Ptf == NULL || Ptf->N == 0) return 0; *elem = (Ptf)->fila[Ptf->IF]; return 1; }
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 Filas implementadas por contiguidade física SOLUÇÃO 1
Algoritmo:Criar Fila comalocação estáticaFila *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; }
Algoritmo: Verifica se fila está cheiaint 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; }
Algoritmo: Verifica se fila está cheiaint E_vazia(Fila *Ptf) –solução 1 int E_vazia(Fila *Ptf) { if (Ptf->IF == Ptf->FF) return 1; else return 0; }
Fila por contiguidade Inserção de um nodo de uma fila Solução 1 • Nodo inserido sempre no final da fila LI IF LS FF 0 1 2 3 4 5 6 7 8 9 10 12 13 14 FILA IF FF LI LS 0 1 2 3 4 5 6 7 8 9 10 12 13 14 FILA
Algoritmo:Inserir nodo na fila (solução 1)intInsere_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; }
Fila por contiguidade Remoção de um nodo de uma fila Solução 1 • Nodo removido é sempre o do início da fila Nodo que pode ser removido LI IF LS FF 0 1 2 3 4 5 6 7 8 9 10 11 12 FILA FF LI IF LS 0 1 2 3 4 5 6 7 8 9 10 11 12 FILA
Algoritmo:Removenodo 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; }
Fila por contiguidade Acesso à fila –solução 1 • Só o nodo do início da fila pode ser acessado • Acesso para consulta Nodo que pode ser acessado LI IF LS FF ?
Fila por contiguidade Algoritmo:Consultar Fila implementada sobre Arranjo (solução 1) int Consulta_fila(Fila Ptf, int *elem) 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:Liberar área alocada para a filaFila* Libera_fila(Fila *Ptf) Fila* Libera_fila(Fila *Ptf) { if (Ptf == NULL) return Ptl; free(Ptf); return NULL; }
Filas Filas implementadas por encadeamento
Filas por encadeamento Inicio Final Inserções Exclusões e Consultas F1 Fn F3 F2 Filas implementadas por encadeamento struct no{ int info; struct no* prox; }; PtFila Info prox Para acessar o último nodo, é necessário percorrer toda a fila a partir do primeiro nodo
Filas por encadeamento Filas por encadeamento com descritor Descritor Prim: primeiro da fila Ult : último da fila Tipo de dados para o descritor da fila: struct desc_q{ struct no* Prim; struct no* Ult; }; typedef struct desc_q Fila; PtDF Prim Ult L1 L2 L3 L4
Filas por encadeamento Operações sobre Filas implementadas por encadeamento com 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 Criação da fila encadeada • Alocar o descritor da fila • Descritor inicializado em endereços nulos • Fila vazia PtDF Prim Ult
Filas por encadeamento Algoritmo: Criar Fila Encadeadaendereçada por descritor Fila* Cria_fila(void) Fila* Cria_Fila(void) { Fila *Ptf; Ptf = (Fila*) malloc (sizeof(Fila)); if (Ptf == NULL) return NULL; Ptf->Prim = NULL; Ptf->Ult = NULL; return Ptf; }