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: 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 0 1 2 3 4 5 6 7 8 9 10 12 13 14 15 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 75 013254 5 LI LS 58 FILA LILS FF 584 FILA LIFF=LS FILA 5 841 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 1 013254 013254 013254 013254 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 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

16 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

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

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

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

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

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

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

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