Denise Guliato Faculdade de Computação – UFU

Apresentação em tema: "Denise Guliato Faculdade de Computação – UFU"— Transcrição da apresentação:

1 Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato
Filas Denise Guliato Faculdade de Computação – UFU 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 Operações válidas: Início Final Criar uma fila vazia
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ço da fila Processo: percorre a fila e imprime os elementos Saida: 1 se sucesso; 0 se fracasso (fila inexistente)

12 Filas Filas implementadas por contiguidade física

13 Fila implementada sobre arranjo
Fila por contiguidade Fila implementada sobre arranjo Exclusões e Consultas Inserções IF FF LS FILA IF : início da fila FF : final da fila LS : limite superior da área (MAX_FILA-1) Fila vazia (?) IF = FF = 0

14 Evolução da Fila 3 3 7 3 7 5 7 5 Fila por contiguidade
LI=IF=FF FILA LI=IF FF LS 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 LI=IF FF LS 3 7 FILA LI=IF FF LS 3 7 5 FILA LI IF FF LS 7 5 FILA

15 Evolução da Fila (cont.)
Fila por contiguidade Evolução da Fila (cont.) LS IF LI 1 3 2 5 4 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 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 1 3 2 5 4 5 FILA LI FF IF LS 1 3 2 5 4 5 8 FILA LI IF FF=LS 1 3 2 5 4 5 8 4 FILA LI IF LS FF 9. Inserir um novo nodo com valor 6 1 3 2 5 4 5 8 4 1 FILA E AGORA ?

16 Ocupação circular do arranjo
Fila por contiguidade Ocupação circular do arranjo IF LI LS FF FILA LS FF IF LI FILA LS = FF IF LI FILA LS IF LI ==FF FILA LS FF IF LI FILA

17 Ocupação circular do arranjo
LS FF IF LI FILA LS FF IF LI FILA LS FF IF LI FILA LS FF = IF LI FILA

18 Ocupação circular do arranjo
FILA VAZIA  IF==FF LS IF = FF LI = FILA FILA CHEIA  IF==FF LS FF = IF LI FILA COMO RESOLVER ESSE PROBLEMA??

19 Algoritmo: Verifica se 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 IF LI 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: Verifica se 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 Operações sobre Filas implementadas por contiguidade física
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 Fila cheia: se N == MAX_FILA Fila vazia : se N == 0
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

25 Algoritmo: Criar Fila com alocação estática Fila
Algoritmo: Criar Fila com alocação estática Fila* 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á cheia int E_cheia(Fila
Algoritmo: Verifica se fila está cheia int 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á cheia int E_vazia(Fila
Algoritmo: Verifica se fila está cheia int E_vazia(Fila *Ptf) –solução 2 int E_vazia(Fila *Ptf) { if (Ptf->N == 0) return 1; else return 0; }

28 Nodo inserido sempre no final da fila (insere e atualiza FF)
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 FILA LI IF LS = FF FILA N = 7

29 Algoritmo: Inserir nodo na fla Fila. Insere_fila(Fila
Algoritmo: Inserir nodo na fla Fila* 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++; }

30 Nodo que pode ser removido
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 FF LS FILA FF LI IF LS FILA N=5

31 Algoritmo: Remove nodo da fila Fila. Remove_fila(Fila. Ptp, int
Algoritmo: Remove nodo da fila Fila* 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--; }

32 Algoritmo: Consultar Fila implementada sobre Arranjo (solução 2)
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 fila Fila Libera_fila(Fila Ptf) Ambas as soluções
{ 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 com alocação estática 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á cheia int E_cheia(Fila
Algoritmo: Verifica se fila está cheia int 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á cheia int E_vazia(Fila
Algoritmo: Verifica se fila está cheia int E_vazia(Fila *Ptf) –solução 1 int E_vazia(Fila *Ptf) { if (Ptf->IF == Ptf->FF) return 1; else return 0; }

38 Nodo inserido sempre no final da fila
Fila por contiguidade Inserção de um nodo de uma fila Solução 1 Nodo inserido sempre no final da fila LI IF FF LS FILA LI IF FF LS FILA

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

40 Nodo que pode ser removido
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 FF LS FILA FF LI IF LS FILA

41 Algoritmo: Remove nodo na fila Fila. Remove_fila(Fila. Ptf, int
Algoritmo: Remove nodo na fila Fila* 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 Nodo que pode ser acessado
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 FF LS ?

43 Algoritmo: Consultar Fila implementada sobre Arranjo (solução 1)
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 fila Fila. Libera_fila(Fila
Algoritmo: Liberar área alocada para a fila Fila* 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
Filas implementadas por encadeamento Inserções Exclusões e Consultas Final Inicio struct no{ int info; struct no* prox; }; PtFila Info prox F1 F2 F3 Fn 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 Encadeada endereç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; }

51 Filas por encadeamento
Inserção de um nodo na fila encadeada PtDFila Prim Ult / PtDFila Prim Ult PtDFila Prim Ult PtDFila Prim Ult

52 Filas por encadeamento
Algoritmo:Inserir novo nodo em Fila Encadeada endereçada por descritor Fila* Insere_Fila(Fila* Ptf, int elem) 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; }

53 Filas por encadeamento
Remoção de um nodo de fila encadeada PtDFila Prim Ult PtDFila Prim Ult / / PtDFila Prim Ult / PtDFila Prim Ult

54 Filas por encadeamento
Algoritmo: Remover um nodo de Fila Encadeada endereçada por descritor Fila* Remove_fila(Fila* Ptf, int elem) 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; (*Ptf)->Ult = NULL; free(aux); return 1; }

55 Filas por encadeamento
Acesso a um nodo de fila encadeada Só o nodo do início da fila pode ser acessado Acessado diretamente pelo endereço no descritor Prim Ult PtDFila ? /

56 Filas por encadeamento
Algoritmo: Consultar Fila Encadeada endereçada por descritor int Consulta_fila(Fila *Ptf) 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; }

57 Destruição de fila encadeada
Filas por encadeamento Destruição de fila encadeada Prim Ult PtDFila Liberar posições ocupadas pela lista / PtDFila Prim Ult Liberar descritor PtDFila = nulo

58 Filas por encadeamento
Algoritmo: Destruir Fila Encadeada endereçada por descritor Fila* Libera_fila(Fila *Ptf) 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);