A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

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.

Apresentações semelhantes


Apresentação em tema: "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."— Transcrição da apresentação:

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 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ções Exclusões e Consultas FinalInício Filas

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 Filas implementadas por contiguidade física

13 IF : início da fila FF : final da fila LS : limite superior da área (MAX_FILA-1) Fila vazia (?) IF = FF = 0 Inserções Exclusões e Consultas Fila implementada sobre arranjo 0 1 2 3 4 5 6 7 8 9 10 12 13 14 15 LS IFFF FILA Fila por contiguidade

14 Evolução da Fila Fila por contiguidade FILA LI=IFLS 3 FILA LI=IFLS 37 FF FILA LI=IFLS 375 FF FILA LILS 7 5 FF IF 1. Inicializar a fila 2. Inserir um novo nodo com valor 3 3. Inserir um novo nodo com valor 7 4. Inserir um novo nodo com valor 5 5. Remover um nodo FF LI=IF=FF

15 Evolução da Fila (cont.) Fila por contiguidade FILA 75 013254 5 LI LS 58 FILA LILS FF 584 FILA LIFF=LS FILA 5 841 LILSIF 1.Inicializa a fia 2.Inserir um novo nodo com valor 3 3. Inserir um novo nodo com valor 7 4. Inserir um novo nodo com valor 5 5. Remover um nodo 6.Remover um nodo 7.Inserir um novo nodo com valor 8 8.Inserir um novo nodo com valor 4 9.Inserir um novo nodo com valor 1 013254 013254 013254 013254 LI IF FF LS IF FF IF 9. Inserir um novo nodo com valor 6 E AGORA ?

16 LS FF IF LI Ocupação circular do arranjo FILA 0 1 2 3 4 5 6 7 8 9 10 12 13 LS FF IF LI 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 LS IF LI ==FF FILA 0 1 2 3 4 5 6 7 8 9 10 12 13 LS FF IF LI FILA Fila por contiguidade

17 Ocupação circular do arranjo 0 1 2 3 4 5 6 7 8 9 10 12 13 LS FF IF LI FILA 0 1 2 3 4 5 6 7 8 9 10 12 13 LS FF IF LI FILA 0 1 2 3 4 5 6 7 8 9 10 12 13 LS FF IF LI FILA 0 1 2 3 4 5 6 7 8 9 10 12 13 LS FF = IF LI FILA

18 Ocupação circular do arranjo 0 1 2 3 4 5 6 7 8 9 10 12 13 LS IF = FFLI = FILA FILA VAZIA IF==FF FILA CHEIA IF==FF 0 1 2 3 4 5 6 7 8 9 10 12 13 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) 0 1 2 3 4 5 6 7 8 9 10 12 13 FF=LS IFLI 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 Fila cheia: se N == MAX_FILA Fila 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;

22 Operações sobre Filas implementadas 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

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

24 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 struct queue { int fila[MAX_FILA]; int IF; int FF; int N; //numro de elementos na fila }; typedef struct queue Fila;

25 Algoritmo: Fila* Cria_fila(void) –solução 2 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 *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 *Ptf) –solução 2 int E_vazia(Fila *Ptf) { if (Ptf->N == 0) return 1; else return 0; }

28 0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIF LI FILA 0 1 2 3 4 5 6 7 8 9 10 11 12 LS = FFIF LI FILA Inserção de um nodo de uma fila Solução 2 Fila por contiguidade Nodo inserido sempre no final da fila (insere e atualiza FF) N = 6 N = 7

29 Algoritmo: 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++; return Ptf; }

30 0 1 2 3 4 5 6 7 8 9 10 11 12 LS FF IF LI FILA 0 1 2 3 4 5 6 7 8 9 10 11 12 LS FF IF LI FILA Remoção de um nodo de uma fila Solução 2 Fila por contiguidade Nodo removido é sempre o do início da fila Nodo que pode ser removido N=6 N=5

31 Algoritmo: Remove 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--; return Ptf; }

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

33 Algoritmo: Algoritmo: Liberar área alocada para a fila Fila 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 SOLUÇÃO 1

35 Algoritmo: Fila *Cria_fila(void) Algoritmo: Criar Fila com alocação estática 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; }

36 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 *Ptf) –solução 1 int E_vazia(Fila *Ptf) { if (Ptf->IF == Ptf->FF) return 1; else return 0; }

38 0 1 2 3 4 5 6 7 8 9 10 12 13 14 LS FF IFLI FILA 0 1 2 3 4 5 6 7 8 9 10 12 13 14 LS FFIF LI FILA Inserção de um nodo de uma fila Solução 1 Fila por contiguidade Nodo inserido sempre no final da fila

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

40 0 1 2 3 4 5 6 7 8 9 10 11 12 LS FF IFLI FILA 0 1 2 3 4 5 6 7 8 9 10 11 12 LS FF IFLI FILA Remoção de um nodo de uma fila Solução 1 Fila por contiguidade Nodo removido é sempre o do início da fila Nodo que pode ser removido

41 Algoritmo: Remove 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 Acesso à fila –solução 1 Fila por contiguidade Só o nodo do início da fila pode ser acessado Acesso para consulta ? LS FF IFLI Nodo que pode ser acessado

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

44 Algoritmo: 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 Filas implementadas por encadeamento

46 Inserções Exclusões e Consultas FinalInicio F1FnF3F2 PtFila Filas implementadas por encadeamento Filas 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; };

47 Descritor Prim: primeiro da fila Ult : último da fila Filas por encadeamento com descritor Filas por encadeamento PtDF Prim Ult L1L1 L2L2 L4L4 L3L3 struct desc_q{ struct no* Prim; struct no* Ult; }; typedef struct desc_q Fila; Tipo de dados para o descritor da fila:

48 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

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

50 Algoritmo: Criar Fila Encadeada endereçada por descritor 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; }

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

52 Algoritmo: Algoritmo:Inserir novo nodo em Fila Encadeada endereçada por descritor Fila* 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; }

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

54 Algoritmo: Remover um nodo de Fila Encadeada endereçada por descritor Fila* 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; }

55 PtDFila Prim Ult / ? 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

56 Algoritmo: Consultar Fila Encadeada endereçada por descritor int 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; }

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

58 Algoritmo: Destruir Fila Encadeada endereçada por descritor Fila* 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; }


Carregar ppt "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."

Apresentações semelhantes


Anúncios Google