Fila

UNIDADE FEDERAL DE SÃO CARLOS
Centro de Ciências Exatas e Tecnologia
Departamento de Computação
Algoritmos e Estruturas de Dados 1
F3 – TAD Fila: implementação, teste e aplicação
Professor: Roberto Ferrari Junior
Autor
Pietro Minghini Moralles
792238
Ciência da Computação
São Carlos, 24 de janeiro de 2022

1. Introdução
2. Descrição da execução das atividades
3. Aplicação de Fila
1 Introdução
Nesta atividade, foi proposta a implementação da estrutura de dados Fila, como um

tipo abstrato de dado. A estrutura fila é do tipo FIFO (first-in first-out), em que o primeiro
elemento a ser inserido é o primeiro a sair. Há dois tipos de implementação do tipo
alocação sequencial e estática de memória, sendo um deles o tipo fila com realocação de
elementos e o outro fila sem realocação de elementos, onde no primeiro os elementos do
vetor são movidos para reordenar a fila, e no segundo, não ocorre esse tipo de
reordenação. Tomei a liberdade de implementar os dois tipos de fila, porém, inseri no
relatório apenas a fila com realocação de elementos, para minimizar o tamanho do
relatório. A primeira figura abaixo representa a fila com reordenação dos elementos, e a
segunda sem.
FIGURA 1: FILA COM REALOCAÇÃO DE ELEMENTOS
FIGURA 2: FILA SEM REALOCAÇÃO DE ELEMENTOS
2 Descrição da execução das atividades
Seguem agora, os trechos de códigos referente a fila com realocação de elementos,

em que o código “Fila_TAD.h” representa o tipo abstrato de dado fila, o código
“Fila_TAD.c” representa as implementações das funções do TAD, e o código “main.c”
representa o código principal.
TRECHO 1: FILA_TAD.H
/*
NOME: PIETRO MINGHINI MORALLES
RA: 792238
DISCIPLINA: Algoritmos e Estruturas de Dados 1
EXERCICIO: F3 - TAD Fila: implementação, teste e aplicação.
DESCRIÇÃO: DECLARAÇÃO DO TAD FILA
*/
#include <stdbool.h>
#define MAX 5
typedef struct {
int elementos[MAX];
int ultimo;
} Fila;
void Cria(Fila *F);
bool Vazia(Fila *F);
bool Cheia(Fila *F);
void Insere(Fila *F, int x, bool *result);
void Retira(Fila *F, int *x, bool *result);
TRECHO 2: FILA_TAD.C
/*
RA: 792238
DESCRIÇÃO: IMPLEMENTAÇÃO DAS FUNÇÕES TAD FILA
*/
#include "Fila_TAD.h"
void Cria(Fila *F){

F->ultimo = -1;
};
bool Vazia(Fila *F){

if(F->ultimo == -1){
return true;
}
else{
return false;
}
};
bool Cheia(Fila *F){
if(F->ultimo == MAX - 1){
return true;
}
else{
return false;
}
};
void Insere(Fila *F, int x, bool *result){

if(Cheia(F) == false) {
F->elementos[F->ultimo + 1] = x;
F->ultimo += 1;
*result = true;
}
else{
*result = false;
}
};
void Retira(Fila *F, int *x, bool *result){

if(Vazia(F) == false){
*x = F->elementos[0];
for(int i = 0; i < F->ultimo; i++){
F->elementos[i] = F->elementos[i+1];
}
F->ultimo = F->ultimo - 1;
*result = true;
}
else{
*result = false;
}
};
TRECHO 3: MAIN.C
/*
RA: 792238
DESCRIÇÃO: ATIVIDADE PARA IMPLEMENTAR E TESTAR O TAD FILA SEM
REALOCAÇÃO DOS ELEMENTOS
*/
#include "Fila_TAD.h"
#include <stdio.h>
void imprimirPrimeiro(Fila *f);

void imprimeFila(Fila *f);
int main() {
int op = 10, valor;
bool resultado;
Fila fila1;
Cria(&fila1);
while (op != 0){

printf("(1) Cheia -- (2) Vazia -- (3) Insere -- (4) Remove
-- (5) Imprime Primeiro -- (6) Imprime Fila: ");
scanf("%d", &op);
if(op == 1){
resultado = Cheia(&fila1);
if(resultado){
printf("Fila cheia\n");
}
else{
printf("N cheia\n");
}
}
else if(op == 2){
resultado = Vazia(&fila1);
if(resultado){
printf("Fila vazia\n");
}
else{
printf("N vazia\n");
}
}
else if(op == 3){
scanf("%d", &valor);
Insere(&fila1, valor, &resultado);
if(resultado){
printf("Inserido %d\n", valor);
}
else{
printf("Fila cheia\n");
}
}
else if(op == 4){
Retira(&fila1, &valor, &resultado);
if(resultado){
printf("Retirou %d\n", valor);
}
else{
}
}
else if(op == 5){
imprimirPrimeiro(&fila1);
}
else if(op == 6){
imprimeFila(&fila1);
}
}
return 0;
}
void imprimirPrimeiro(Fila *f){

Fila aux;
Cria(&aux);
int x, qtdVz = 0;
bool resultado;
if(Vazia(f)){
}
else{
while(!Vazia(f)) {
if(qtdVz == 0) {
Retira(f, &x, &resultado);
printf("O primeiro elemento eh: %d\n", x);
Insere(&aux, x, &resultado);
qtdVz++;
}
else{
}
}
while (!Vazia(&aux)){
Retira(&aux, &x, &resultado);
Insere(f, x, &resultado);
}
}
};
void imprimeFila(Fila *f){

Fila aux;
Cria(&aux);
int x;
bool resultado;
if(Vazia(f)){
}
else{
while (!Vazia(f)){
}
printf("Inicio -----> ");
while (!Vazia(&aux)){
Retira(&aux, &x, &resultado);
printf("%d ", x);
Insere(f, x, &resultado);
}
printf("\n");
}
}
Seguem agora, prints da execução da implementação da fila com realocação de

elementos.
FIGURA 3: TESTE FILA COM REALOCAÇÃO DE ELEMENTOS 1
FIGURA 3: TESTE FILA COM REALOCAÇÃO DE ELEMENTOS 2
3 Aplicação de Fila
Uma aplicação de Fila que eu pensei, poderia ser a fila de um jogo em que o servidor
possuí limite de pessoas. Neste jogo, há um sistema de jogadores VIP e jogadores não
VIP, em que, a vantagem de se ser um jogador VIP estaria na fila de espera para jogar,
uma vez que jogadores VIP’s teriam prioridades para entrar no jogo, estando assim
sempre a frente na fila de jogadores, comparado aos não VIP’s. Entretanto, para não ficar
muito injusto, a cada 5 jogadores VIP’s que entram no jogo, um jogador não VIP entra
no jogo também, para não deixar apenas jogadores VIP no jogo.
A ideia seria uma fila para jogadores VIP, uma fila para jogadores não VIP e uma
ultima fiz que consiste da união das duas filas, sendo a VIP primeiro e depois a não VIP.
Cada jogador VIP que entra na fila, é adicionado na fila VIP e depois ocorre a junção,
novamente, das duas filas. O mesmo se aplica para os não VIP.
Assim, a cada 5 jogadores VIP, o próximo jogador a entrar seria o primeiro jogador
não VIP. A junção das duas é utilizada para informar a posição geral do jogador na fila
de jogadores. Utilizando as operações primitivas, é possível criar tais operações, de modo
a utilizar o “controle da TV”.

Fila

Enviado por

Direitos autorais:

Formatos disponíveis

Fila

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Fila

Enviado por

Direitos autorais:

Formatos disponíveis

UNIDADE FEDERAL DE SÃO CARLOS

Centro de Ciências Exatas e Tecnologia

Algoritmos e Estruturas de Dados 1

F3 – TAD Fila: implementação, teste e aplicação

Professor: Roberto Ferrari Junior

Pietro Minghini Moralles

São Carlos, 24 de janeiro de 2022

Nesta atividade, foi proposta a implementação da estrutura de dados Fila, como um

Seguem agora, os trechos de códigos referente a fila com realocação de elementos,

void Cria(Fila *F);

bool Vazia(Fila *F);

bool Cheia(Fila *F);

void Insere(Fila *F, int x, bool *result);

void Retira(Fila *F, int *x, bool *result);

void Cria(Fila *F){

bool Vazia(Fila *F){

void Insere(Fila *F, int x, bool *result){

void Retira(Fila *F, int *x, bool *result){

void imprimirPrimeiro(Fila *f);

while (op != 0){

void imprimirPrimeiro(Fila *f){

void imprimeFila(Fila *f){

Seguem agora, prints da execução da implementação da fila com realocação de

FIGURA 3: TESTE FILA COM REALOCAÇÃO DE ELEMENTOS 2

Você também pode gostar

void Insere(Fila F, int x, bool result);

void Retira(Fila F, int x, bool *result);

void Insere(Fila F, int x, bool result){

void Retira(Fila F, int x, bool *result){