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

12 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

13 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

14 Evolução da Fila (cont.)
Fila por contiguidade Evolução da Fila (cont.) LS IF LI 1 3 2 5 4 7 5 FILA LI IF FF LS 1 3 2 5 4 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 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 ?

15 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

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
FILA VAZIA  IF==FF LS IF = FF LI = FILA 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 IF LI 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 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

21 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

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

23 Algoritmo: Criar Fila com alocação estática 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
{ 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
{ if (Ptf->IF == Ptf->FF) return 1; else return 0; }

26 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

27 Algoritmo: Inserir nodo na fila (solução 1) 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 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

29 Algoritmo: Remove nodo na fila int. Remove_fila(Fila. Ptf, int
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 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 ?

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

32 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

34 Fila cheia: se N == MAX_FILA Fila vazia : se N == 0
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

35 Algoritmo: Criar Fila com alocação estática Fila Cria_fila(void) –solução 2
{ 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
{ 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
{ if (Ptf->N == 0) return 1; else return 0; }

38 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

39 Algoritmo: Inserir nodo na fla int Insere_fila(Fila
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 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

41 Algoritmo: Remove nodo da fila int Remove_fila(Fila. Ptp, int
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: 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) return 0; if ((Ptf)->N == 0) return 0; // fila vazia *elem = (Ptf)->fila[(Ptf)->IF]; return 1; }

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

44 Filas Filas implementadas por encadeamento

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

46 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

47 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

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

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

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

51 Filas por encadeamento
Algoritmo:Inserir novo nodo em Fila Encadeada endereçada por descritor Int Insere_Fila(Fila* Ptf, int elem) 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 Filas por encadeamento
Remoção de um nodo de fila encadeada PtDFila Prim Ult PtDFila Prim Ult / / PtDFila Prim Ult / PtDFila Prim Ult

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

54 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 ? /

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

56 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

57 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 ->elo free(Pt); } free(Ptf);