Você está na página 1de 15

15/09/2014

Estrutura de Dados
Tema 4: Filas.

O que é uma fila (queue)

Um conjunto de itens dispostos linearmente,


onde a inserção de itens acontece em uma
extremidade e a remoção acontece na outra.

fim R fim
H
E 1 4 5 9
A
inicio inicio

Características de uma fila


• É um objeto dinâmico, compreendendo a
possibilidade de inserção e remoção de
elementos sucessivamente;
• Não há limite de tamanho;
• Fornece acesso apenas
ao elemento localizado
no início (para remoção)
e no fim (para inserção);
• Chamada de lista FIFO
(first in first out)

1
15/09/2014

Analisando uma fila graficamente

Inserir os elementos 3, 5, 6, 1, 3 na fila 1

Analisando uma fila graficamente


Remover os elementos da fila
H fim
E
A início

Fila como um Tipo de Dado Abstrato


Características:
• Conjunto de elementos;
• Início para indicar o 1º elemento inserido
• Fim para indicar o último elemento inserido

Operações:
• Inserir novo elemento
• Remover elemento
• Verificar se fila está vazia.

2
15/09/2014

Funções Empty e Insere

abstract empty(fila)
SE tem algum elemento no Início retorne FALSE
SENÃO retorne TRUE
fim empty

abstract insere(fila, el)


fila  fila + el
atualiza fim
fim insere

Função Remove

abstract remove(fila)
aux  fila(inicio)
fila  fila – fila(inicio)
atualiza inicio
retorne aux
fim remove

Representando uma fila em C usando


vetor
#define TAM 100
struct fila {
char itens[TAM];
int inicio;
int fim;
};

3
15/09/2014

Representando uma fila em C usando


vetor
...
struct fila f;
f.inicio = 0;
f.fim = -1;

Continuando
Tema 3: Filas.

Implementando uma Fila em C (vetor)

#include <stdio.h>
#include <stdlib.h>
#define TAM 100
struct fila {
char itens[TAM];
int inicio;
int fim;
};

4
15/09/2014

void insere(struct fila *f, int el) {


if (f->fim == TAM -1) //fila cheia
exit(1);
else
{ f->fim = f->fim + 1;
f->itens[f->fim] = el;
}
}

int empty(struct fila *f) {


if (f->fim < f->inicio)
return true;
else return false;
}

int remove(struct fila *f) {


int aux;
if (empty(f) == true)
exit(1);
else {
aux = f->itens[f->inicio];
f->inicio = f->inicio + 1;
return aux;
}
}

5
15/09/2014

int main() {
int op, el;
struct fila f;
f.inicio = 0; f.fim = -1;
do {printf(“\n1-Inserir \n2-Remover \n3-
Encerrar”);
scanf(“%d”, &op);
if(op ==1) {
printf(“\nNumero?”);
scanf(“%d”, &el);

insere(&f, el);
}
if (op ==2) {
int aux =remove(&f);
printf(“\nRemovido: %d”, aux);
}
} while (op !=3);
} //fim main

Resolvendo limitações da solução


anterior

6
15/09/2014

#include <stdio.h>
#include <stdlib.h>
#define TAM 5

struct fila {
char itens[TAM];
int inicio;
int fim;
};

void insere(struct fila *f, int el) {


if (f->fim == TAM -1)
f->fim = 0;
else f->fim = f->fim + 1;
if (f->fim == f->inicio) {
printf("\nEstouro na fila.\n");
system("pause");
exit(1);
}
else f->itens[f->fim]= el;}

int empty(struct fila *f) {


if (f->fim == f->inicio)
return 1;
else return 0;
}

7
15/09/2014

int remove(struct fila *f) {


if (empty(f) == true) {
printf("\nUnderflow na fila. \n");
system("pause");
exit(1); }
else {
if (f->inicio == TAM -1)
f->inicio = 0;
else f->inicio = f->inicio + 1;
return f->itens[f->inicio];
} }

int main() {
int op, el;
struct fila f;
f.inicio = f.fim = TAM - 1;
do { printf("\n1-Inserir \n2-Remover \n3-
Encerrar");
scanf("%d", &op);
if(op ==1) {
printf("\nNumero?");
scanf("%d", &el);
insere(&f, el); }

if (op ==2) {
int aux =remove(&f);
printf("\nRemovido: %d", aux);
}
} while (op !=3);
} //fim main

8
15/09/2014

Agora é sua Vez

Tema 4: Filas.

Implementando uma Fila em C


(dinâmica)
f
810AB início
436C2 fim

10 30

810AB 436C2

#include <stdio.h>
#include <stdlib.h>

struct elemento {
int num;
elemento *prox; };

struct fila {
elemento *inicio;
elemento *fim; };

9
15/09/2014

void insere(struct fila *f, int el) {


elemento *novo;
novo = new(elemento);
novo->num = el;
novo->prox = NULL;
if (f->inicio == NULL) {
f->inicio = novo;
f->fim = novo;
}

else { f->fim->prox = novo;


f->fim = novo;
}
}

int empty(struct fila *f) {


if (f->inicio == NULL)
return true;
else return false;
}

int remove(struct fila *f) {


elemento *aux;
int n;
if (empty(f) == true) exit(1);
else
{ n = fila->inicio->num;
aux = fila->inicio;
fila->inicio=aux->prox;
delete aux;
return n; }
}

10
15/09/2014

int main() {
int op, el;
struct fila f;
f.inicio = NULL; f.fim= NULL;
do { printf("\n1-Inserir \n2-Remover
\n3-Encerrar");
scanf("%d", &op);
if(op ==1) {
printf("\nNumero?");
scanf("%d", &el);

insere(&f, el);
}
if (op ==2)
el = pop(&f);
printf("\nRemovido: %d", el);
}
} while (op !=3);
} //fim main

Finalizando
Tema 4: Filas.

11
15/09/2014

Deques (double-ended queue)

inserir_i inserir_f

remover_i remover_f

Estruturas parecidas com


as filas, mas que
permitem inserções e
remoções em ambas as
extremidades.

Operações em um Deque
remover_i(d) Remove do inicio do deque
inserir_i(d, e) Insere no início do deque
remover_f(d) Remove do fim do deque
inserir_f(d, e) Insere no fim do deque
empty(d) Verifica se deque está vazio
listar(d) Lista todos os elementos do deque


struct elemento {
int num;
struct elemento *prox;
struct elemento *ant;
};
struct deque {
struct elemento *inicio;
struct elemento *fim;
};

12
15/09/2014

void inserir_i(deque *d, int n) {


elemento *novo;
novo = new(elemento);
novo->num = n;
novo->prox=d->inicio;
novo->ant = NULL;
if (d->inicio == NULL)
d->fim = novo;
d->inicio=novo;
}

void remover_i(deque *d) {


if (empty(d)) return;
else { elemento *aux = d->inicio;
d->inicio=d->inicio->prox;
if (d->inicio!=NULL)
d->inicio->ant = NULL;
else d->fim = NULL;
free(aux);
}
}

void inserir_f(deque *d, int n) {


elemento *novo;
novo = new(elemento);
novo->num = n;
novo->prox=NULL;
novo->ant = d->fim;
d->fim->prox=novo;
d->fim=novo;
}

13
15/09/2014

void remover_f(deque *d) {


if (empty(d)) return;
else { elemento *aux = d->fim;
d->fim=d->fim->ant;
if (d->fim!=NULL)
d->fim->prox = NULL;
else d->inicio = NULL;
free(aux);
}
}

void listarElementos(elemento *e) {


if (e==NULL) return;
else printf("%d\n",e->num);
listarElementos(e->prox);
}
void listar (deque d)
{ if (empty(&d))
return;
else listarElementos(d.inicio);
}

int empty (deque *d) {


if (d->inicio==NULL) return true;
else return false;
}

14
15/09/2014

Conclusões

• Filas também representam um tipo de dado


abstrato linear, capaz de armazena infinitos
elementos;
• As inserções acontecem em uma extremidade
e as remoções na outra;
• Só pode ser acessado o
primeiro elemento da
fila. Ele pode ser
visualizado e removido -
FIFO

15