filas denise guliato faculdade de computação – ufu guliato vários slides foram adaptados de...

FilasFilas

Denise GuliatoFaculdade de Computação – UFUwww.facom.ufu.br/~guliato

Vários slides foram adaptados de Nina Edelwais e Renata GalanteEstrutura de Dados – Série de Livros Didáticos - Informática - UFRGS

Pilhas e filasPilhas e filas

FilasFilas

FilasFilas

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çõesExclusões

eConsultas

FinalInício

Filas

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

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

TAD FilaTAD Fila

Cria_fila entrada: nenhuma processo: aloca área para a fila e a coloca na

condição de vazia saida: endereço da fila

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

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

TAD FilaTAD 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).

TAD FilaTAD Fila

Libera_fila entrada: o endereço da fila processo: libera toda area alocada para a fila saida: o endereço da fila

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

FilasFilas

Filas Filas implementadas por implementadas por contiguidade físicacontiguidade física

IF : início da filaFF : final da filaLS : limite superior da área (MAX_FILA-1)

Fila vazia (?)Fila vazia (?)

IF = FF = 0

Inserções

ExclusõeseConsultas

Fila implementada sobre arranjoFila implementada sobre arranjo

0 1 2 3 4 5 6 7 8 9 10 12 13 14 15LS IF FF

FILA

Fila por contiguidade

Evolução da FilaEvolução da FilaFila por contiguidade

FILA

FILA

LI=IF LS

3

FILA

LI=IF LS

3 7

FF

FILA

LI=IF LS

3 7 5

FF

FILA

LI LS

7 5

FFIF

1. Inicializar a fila2. Inserir um novo nodo com valor 33. Inserir um novo nodo com valor 74. Inserir um novo nodo com valor 55. Remover um nodo

FF

LI=IF=FF

Evolução da Fila (cont.)Evolução da Fila (cont.)Fila por contiguidade

FILA 7 5

0 1 32 54

5FILA

LI LS

5 8FILA

LI LSFF

5 8 4FILA

LI FF=LS

FILA 5 8 4 1

LI LSIF

1. Inicializa a fia2. Inserir um novo nodo com valor 33. Inserir um novo nodo com valor 74. Inserir um novo nodo com valor 55. Remover um nodo6. Remover um nodo7. Inserir um novo nodo com valor 88. Inserir um novo nodo com valor 49. Inserir um novo nodo com valor 1

0 1 32 54

0 1 32 54

0 1 32 54

0 1 32 54

LI IF

FF

LS

IF

IF

FF

IF

9. Inserir um novo nodo com valor 6

E AGORA ?

LSFFIF

LI

Ocupação circular do arranjoOcupação circular do arranjo

FILA 0 1 2 3 4 5 6 7 8 9 10 12 13

0 1 2 3 4 5 6 7 8 9 10 12 13LSFFIFLI

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 LSIFLI ==FF

FILA

0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI

FILA

Fila por contiguidade

Ocupação circular do arranjoOcupação circular do arranjo

0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF IFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF= IFLI

FILA

Ocupação circular do arranjoOcupação circular do arranjo

0 1 2 3 4 5 6 7 8 9 10 12 13LSIF = FFLI =

FILA

FILA VAZIA IF==FF

FILA CHEIA IF==FF

0 1 2 3 4 5 6 7 8 9 10 12 13 LSFF= IFLI

FILA

COMO RESOLVER ESSE PROBLEMA??

AlgoritmoAlgoritmo: Verifica: Verifica se fila está cheia/vaziase fila está cheia/vazia

Solução 1: desperdício de um nodo

Inicialização da fila: IF = 0 e FF = 0Inserçã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=LSIFLI

FILA

Fila cheia: se (FF+1)%MAX_FILA == IFFila vazia : se IF == FF

Tipo de dados utilizado para a fila com Tipo de dados utilizado para a fila com alocação estática para solução 1alocação estática para solução 1

struct queue { int fila[MAX_FILA]; int IF; int FF; };

typedef struct queue Fila;

AlgoritmoAlgoritmo: Verifica: Verifica se fila está cheia/vaziase fila está cheia/vazia

Solução 2: alterar o tipo de dados

Inicialização da fila: IF = 0, FF = 0 e N=0Inserção: insere em FF, atualiza FF e NFila cheia: se N == MAX_FILAFila 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;

Operações sobre FilasOperações sobre Filasimplementadas por contiguidade físicaimplementadas 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

Operações sobre FilasOperações sobre Filasimplementadas por contiguidade físicaimplementadas por contiguidade física

SOLUÇÃO 2SOLUÇÃO 2

Inicialização da fila: IF = 0, FF = 0 e N=0Inserção: insere em FF, atualiza FF e N

Fila cheia: se N == MAX_FILAFila 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;

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

AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_cheia(Fila *Ptf) –solução 2int E_cheia(Fila *Ptf) –solução 2

int E_cheia(Fila *Ptf){ if (Ptf->N == MAX_FILA) return 1; else return 0;}

AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_vazia(Fila *Ptf) –solução 2int E_vazia(Fila *Ptf) –solução 2

int E_vazia(Fila *Ptf){ if (Ptf->N == 0) return 1; else return 0;}

0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 11 12 LS = FFIFLI

FILA

Inserção de um nodo de uma fila Inserção de um nodo de uma fila Solução 2Solução 2

Fila por contiguidade

• Nodo inserido sempre no final da fila (insere e atualiza FF)

N = 6

N = 7

Algoritmo:Algoritmo: Inserir nodo na flaFila* 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;}

0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI

FILA

Remoção de um nodo de uma fila Remoção de um nodo de uma fila Solução 2Solução 2

Fila por contiguidade

• Nodo removido é sempre o do início da fila

Nodo que pode ser removidoN=6

N=5

Algoritmo:Algoritmo: Remove Remove nodo da filaFila* 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;}

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

Algoritmo:Algoritmo: Liberar área alocada para a filaFila Libera_fila(Fila Ptf) Ambas as soluções

Fila *Libera_fila(Fila *Ptf){ if (Ptf == NULL) return Ptl; free(Ptf); return NULL;}

Operações sobre FilasOperações sobre Filasimplementadas por contiguidade físicaimplementadas por contiguidade física

SOLUÇÃO 1SOLUÇÃO 1

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

AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_cheia(Fila *Ptf) –solução 1int 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;}

AlgoritmoAlgoritmo: Verifica se fila está cheia: Verifica se fila está cheiaint E_vazia(Fila *Ptf) –solução 1int E_vazia(Fila *Ptf) –solução 1

int E_vazia(Fila *Ptf){ if (Ptf->IF == Ptf->FF) return 1; else return 0;}

0 1 2 3 4 5 6 7 8 9 10 12 13 14LSFFIFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 12 13 14 LSFFIFLI

FILA

Inserção de um nodo de uma fila Inserção de um nodo de uma fila Solução 1Solução 1

Fila por contiguidade

• Nodo inserido sempre no final da fila

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

0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI

FILA

0 1 2 3 4 5 6 7 8 9 10 11 12 LSFFIFLI

FILA

Remoção de um nodo de uma fila Remoção de um nodo de uma fila Solução 1Solução 1

Fila por contiguidade

• Nodo removido é sempre o do início da fila

Nodo que pode ser removido

Algoritmo:Algoritmo: Remove Remove nodo na filaFila* 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;}

Acesso à fila –solução 1Acesso à fila –solução 1Fila por contiguidade

• Só o nodo do início da fila pode ser acessado

• Acesso para consulta

?

LSFFIFLI

Nodo que pode ser acessado

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

Algoritmo:Algoritmo: Liberar área alocada para a filaFila* Libera_fila(Fila *Ptf)

Fila* Libera_fila(Fila *Ptf){ if (Ptf == NULL) return Ptl; free(Ptf); return NULL;}

FilasFilas

Filas Filas implementadas por implementadas por encadeamentoencadeamento

InserçõesExclusões e

Consultas

FinalInicio

F1 FnF3F2

PtFila

Filas implementadas por encadeamentoFilas implementadas por encadeamentoFilas 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; };

Descritor

Prim: primeiro da filaUlt : último da fila

Filas por encadeamento com descritorFilas por encadeamento com descritorFilas por encadeamento

PtDF

Prim Ult

L1 L2 L4L3

struct desc_q{ struct no* Prim; struct no* Ult; };typedef struct desc_q Fila;

Tipo de dados para o descritor da fila:

Operações sobre FilasOperações sobre Filasimplementadas por encadeamentoimplementadas por encadeamentocom descritorcom 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

Filas por encadeamento

• Alocar o descritor da fila

• Descritor inicializado em endereços nulos • Fila vazia

Criação da fila encadeadaCriação da fila encadeada

PtDF

Prim Ult

Algoritmo:Algoritmo: Criar Fila Encadeada endereçada por descritorFila* Cria_fila(void)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; }

PtDFila Prim Ult

PtDFila Prim Ult

/

PtDFila Prim Ult

Filas por encadeamento

Inserção de um nodo na fila encadeadaInserção de um nodo na fila encadeada

PtDFila Prim Ult

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

PtDFila Prim Ult

/

PtDFila Prim Ult

/

Filas por encadeamento

Remoção de um nodo de fila encadeadaRemoção de um nodo de fila encadeada

PtDFila Prim Ult

/

PtDFila Prim Ult

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

PtDFila Prim Ult

/??

Filas por encadeamento

Acesso a um nodo de fila encadeadaAcesso a um nodo de fila encadeada

• Só o nodo do início da fila pode ser acessado

• Acessado diretamente pelo endereço no descritor

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

PtDFila

/

Prim Ult

Filas por encadeamento

Destruição de fila encadeadaDestruição de fila encadeada

PtDFila Prim Ult

PtDFila = nulo

Liberar posições ocupadas pela lista

Liberar descritor

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