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 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: a 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: a 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: 1 se sucesso, 0 se fracasso

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: 1 se sucesso e 0 se fracasso (fila vazia)

9 TAD Fila Consulta_fila entrada: a 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)

10 TAD Fila Libera_fila entrada: a fila processo: libera toda area alocada para a fila saida: a fila

11 Filas Filas Filas implementadas por contiguidade física

12 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 LS IFFF FILA Fila por contiguidade

13 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

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

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

16 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

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

18 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 IFLI FILA Fila cheia: se (FF+1)%MAX_FILA == IF Fila vazia : se IF == FF

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

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

21 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

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

23 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(struct queue)); if (Ptf != NULL) { Ptf->IF = 0; Ptf->FF = 0; } return Ptf; }

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

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

26 LS FF IFLI FILA 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

27 Algoritmo: Algoritmo: Inserir nodo na fila (solução 1) int Insere_fila(Fila Ptf, int elem) int Insere_fila(Fila* Ptf, int elem) { if (((*Ptf)->FF+1)%MAX_FILA) == (*Ptf)->IF)) return 0; (*Ptf)->FF = ((*Ptf)->FF+1)%MAX_FILA; (*Ptf)->fila[(*Ptf)->FF] = elem; return 1; }

28 LS FF IFLI FILA 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

29 Algoritmo: Remove Algoritmo: Remove nodo na fila int* Remove_fila(Fila *Ptf, int *elem) –solução1 int Remove_fila(Fila* Ptf,int *elem) { if ((*Ptf)->FF == (*Ptf)->IF) return 0; // fila vazia (*Ptf)->IF= ((*Ptf)->IF+1)%MAX_FILA; *elem = (*Ptf)->fila[(*Ptf)->IF]; return 1; }

30 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

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

32 Algoritmo: Algoritmo: Liberar área alocada para a fila void Libera_fila(Fila Ptf) Fila Libera_fila(Fila Ptf) { if (Ptf == NULL) return Ptl; free(Ptf); return NULL; }

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

34 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;

35 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) { FilaPtf; Ptf = (Fila) malloc(sizeof(struct queue)); if (Ptf != NULL) { Ptf->IF = 0; Ptf->FF = 0; Ptf ->N = 0; } return Ptf; }

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

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

38 LSFFIF LI FILA 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

39 Algoritmo: Algoritmo: Inserir nodo na fla int Insere_fila(Fila *Ptf, int elem) -solução2 int Insere_fila(Fila* Ptf, int elem) { if (*Ptf) == NULL) return 0; if ((*Ptf)->N == MAX_FILA) return 0; (*Ptf)->fila[(*Ptf)->FF] = elem; (*Ptf)->FF = ((*Ptf)->FF+1)%MAX_FILA; (*Ptf)->N++; return 1; }

40 LS FF IF LI FILA 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

41 Algoritmo: Remove Algoritmo: Remove nodo da fila int Remove_fila(Fila *Ptp, int *elem) –solução2 int Remove_fila(Fila* Ptf, int *elem) { if (*Ptf) == NULL) return 0; if ((*Ptf)->N == 0) return 0; // fila vazia *elem = (*Ptf)->fila[(*Ptf)->IF]; (*Ptf)->IF= ((*Ptf)->IF+1)%MAX_FILA; (*Ptf)->N--; return 1; }

42 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) return 0; if ((Ptf)->N == 0) return 0; // fila vazia *elem = (Ptf)->fila[(Ptf)->IF]; return 1; }

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

44 Filas Filas Filas implementadas por encadeamento

45 Inserções Exclusões e Consultas FinalInicio F1FnF3F2 PtFila Filas implementadas por encadeamento Filas por encadeamento Info Elo Para acessar o último nodo, é necessário percorrer toda a fila a partir do primeiro nodo struct no{ int info; struct no* elo; };

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

47 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

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

49 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(struct desq_q)); if (Ptf == NULL) return NULL; Ptf->Prim = NULL; Ptf->Ult = NULL; return Ptf; }

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

51 Algoritmo: Algoritmo:Inserir novo nodo em Fila Encadeada endereçada por descritor Int Insere_Fila(Fila* Ptf, int elem) Filas por encadeamento int Insere_Fila(Fila* Ptf, int elem) { struct no *Pt; Pt = (struct no*) malloc (sizeof(struct no)); if (Pt == NULL) return 0; Pt-> info = elem; Pt->elo = NULL; if ((*Ptf)->Ult ==NULL) (*Ptf)->Prim = Pt; else (*Ptf)->Ult->elo = Pt; (*Ptf)->Ult = Pt; return 1; }

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

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

54 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

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

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

57 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 ->elo 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