1 / 58

Filas

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.

gavin
Download Presentation

Filas

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 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

  2. Pilhas e filas Filas

  3. 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

  4. 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

  5. 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

  6. 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

  7. 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

  8. 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

  9. 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).

  10. TAD Fila Libera_fila entrada: o endereço da fila processo: libera toda area alocada para a fila saida: o endereço da fila

  11. TAD Fila Imprime_fila Entrada: o endereçodafila Processo: percorre a fila e imprimeoselementos Saida: 1 se sucesso; 0 se fracasso (filainexistente)

  12. Filas Filas implementadas por contiguidade física

  13. 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

  14. 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

  15. 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 ?

  16. 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

  17. 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

  18. 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??

  19. 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

  20. 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;

  21. 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

  22. 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

  23. Operações sobre Filas implementadas por contiguidade física SOLUÇÃO 2

  24. 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

  25. 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; }

  26. 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; }

  27. 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; }

  28. 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

  29. 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; }

  30. 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

  31. 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; }

  32. 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; }

  33. 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; }

  34. Operações sobre Filas implementadas por contiguidade física SOLUÇÃO 1

  35. 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; }

  36. 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; }

  37. 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; }

  38. 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

  39. 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; }

  40. 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

  41. 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; }

  42. 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 ?

  43. 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; }

  44. 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; }

  45. Filas Filas implementadas por encadeamento

  46. 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

  47. 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

  48. 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

  49. Filas por encadeamento Criação da fila encadeada • Alocar o descritor da fila • Descritor inicializado em endereços nulos • Fila vazia PtDF Prim Ult

  50. 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; }

More Related