LINGUAGEM C

Estrutura de Dados - Fila

Manaus - AM
2017
DANIEL KHALIL RA: D272DJ-0
JORGE PATU RA: D39ICG-6
MATEUS SILVA RA: D32337-7
NAYLCSON ARAÚJO RA: D402DI-3

LINGUAGEM C
Estrutura de Dados - Fila

Trabalho solicitado para obtenção da

nota parcial, da disciplina de
Linguagem e Técnicas de
Programação, Universidade Paulista -
UNIP, turma DS2P34.

Profº. Rildo Nogueria

Manaus - AM
2017
2
 SUMÁRIO

1. INTRODUÇÃO ........................................................................................................ 4

2. FILAS (QUEUE) ..................................................................................................... 5

3. CABEÇALHOS DE FUNÇÕES .............................................................................. 7

4. PALAVRAS RESERVADAS ................................................................................... 7

5. VARIÁVEIS ............................................................................................................. 9
5.1 Tipos de dados ................................................................................................... 10
5.1.1. Tipos de dados mais comuns em linguagem C .............................................. 10
5.2. Sintaxe de declarações de variáveis em C ........................................................ 10
5.3. Endereço de uma variável ................................................................................. 10
5.4. Regras para criação de nomes de variáveis ...................................................... 11
5.5. Endereço de uma variável ................................................................................. 11

6. FUNÇÕES EM “C” ................................................................................................ 11

6.1. Esqueleto de uma função .................................................................................. 12
6.2. Função sem retorno .......................................................................................... 12

7. ESTRUTURA DE REPETIÇÕES FOR ................................................................. 12

7.1. Utilização do comando for ................................................................................. 13
7.2. Estrutura de repetições while ............................................................................ 13
8. ESTRUTURA DE TOMADAS DE DECISÕES ..................................................... 14
8.1. If/else .................................................................................................................. 16
8.2. Switch/case ........................................................................................................ 16

9. OPERAÇÕES DE ENTRADA E SAÍDA DE DADOS EM LINGUAGEM C............. 17

9.1. Saída de dados ................................................................................................. 17
9.2. Protótipos de função em “C”............................................................................... 17
9.2.1. Scanf .............................................................................................................. 17
9.2. Gets ................................................................................................................... 17

10. PARTES FUNDAMENTAIS DE UMA CODIFICAÇÃO EM “C” ........................... 18

11. CONCLUSAO...................................................................................................... 20

REFERENCIAS BIBLIOGRÁFICA ............................................................................ 21

 3

1. INTRODUÇÃO

No dia a dia, estamos acostumados com as filas em diversos lugares: nos

bancos, nos mercados, nos hospitais, nos cinemas, entre outros lugares. As filas são
importantes, pois, determinam a ordem de atendimento das pessoas.
As pessoas são atendidas conforme sua posição na fila. O próximo a ser
atendido é o primeiro da fila. Quando o primeiro da fila é chamado para ser atendido
a fila "anda", ou seja, o segundo passa a ser o primeiro, o terceiro passa a ser o
segundo e assim por diante até a última pessoa. Normalmente, para entrar em uma
fila, uma pessoa deve se colocar na última posição, ou seja, no fim da fila. Desta
forma, quem chega primeiro tem prioridade.
Em Estrutura de dados assim como as Pilhas, as Filas têm operações
mais restritas do que as operações das Listas. Nas Filas, os elementos são
adicionados na última posição e removidos da primeira posição.
 4

2. FILAS (QUEUE)

São estruturas de dados do tipo FIFO (first-in first-out), onde o primeiro

elemento a ser inserido, será o primeiro a ser retirado, ou seja, adicionam-se itens
no fim e remove-se do início.

Imagem 1

Fonte: Professor Ricardo Farias, 2009.

São exemplos de uso de fila em um sistema:

 Controle de documentos para impressão;
 Troca de mensagem entre computadores numa rede;
A implementação de filas pode ser realizada através de vetor (alocação do
espaço de memória para os elementos é contígua) ou através de listas
encadeadas.

2.1. Operações com Fila:

Todas as operações em uma fila podem ser imaginadas como as que

ocorrem numa fila de pessoas num banco, exceto que os elementos não se movem
na fila, conforme o primeiro elemento é retirado. Isto seria muito custoso para o
computador. O que se faz na realidade é indicar quem é o primeiro.

 Criação da fila (informar a capacidade no caso de implementação

sequencial - vetor);
 Enfileirar - o elemento é o parâmetro nesta operação;
 Desenfileirar;
 Mostrar a fila (todos os elementos);
 Verificar se a fila está vazia (isEmpty);
 Verificar se a fila está cheia (isFull - implementação sequencial -
vetor).
 5

Supondo uma fila com capacidade para 5 elementos (5 nós).

Imagem 2

Fonte: Fonte: Professor Ricardo Farias, 2009.

 6

Na realidade a remoção de um elemento da fila é realizada apenas alterando

a informação da posição do último.
Para evitar problemas de não inserir mais elementos na fila, mesmo quando
ela não está cheia, as referências, primeiro e último circundam até o inicio do vetor,
resultando numa fila circular.
Imagem 3

Fonte: Fonte: Professor Ricardo Farias, 2009.

Desta forma a fila simula uma representação circular:

Imagem 4

Fonte: Fonte: Professor Ricardo Farias, 2009.

2.2. Implementação de fila

 Função fila_cria: aloca dinamicamente a estrutura da fila e inicializa
seus campos e retorna seu ponteiro;
 Função fila_insere e função fila_retira: insere e retira, respectivamente,
um valor real na fila;
 Função fila_vazia: informa se a fila está ou não vazia;
 7

 Função fila_libera: destrói a fila, liberando toda a memória usada pela

estrutura. Exemplo:
typedef struct fila Fila;
Fila* fila _ cria (void);
void fila _ insere (Fila* f, float v);
float fila _ retira (Fila* f);
int fila _ vazia (Fila* f);
void fila _ libera (Fila* f);

2.3. Implementação de fila com vetor

 vetor (vet): armazena os elementos da fila.

2.3.1. Estrutura de fila:

#define N 100 /* número máximo de elementos */
struct fila { int n; /* número de elementos na fila */
int ini; /* posição do próximo elemento a ser retirado da
fila */
float vet[N];
};

2.3.2. Inserção
Processo de inserção e remoção em extremidades opostas da fila faz com
que a fila “ande” no vetor;
Inserção dos elementos 1.4, 2.2, 3.5, 4.0.
Imagem 5

Fonte: Paulo Feofiloff, 2016.

2.3.3. Função fila_cria

Aloca dinamicamente um vetor e inicializa a fila como sendo vazia (número de
elementos = 0). Exemplo:
 8

Fila* fila _ cria (void)

{
Fila* f = (Fila*) malloc(sizeof(Fila));
f->n = 0; /* inicializa fila como vazia */
f->ini = 0; /* escolhe uma posição inicial */
return f;
}

2.3.4. Função fila_insere

Insere um elemento no final da fila e usa a próxima posição livre do vetor, se
houver. Exemplo:
void fila _ insere (Fila* f, float v)
{ int fim;
if (f->n == N) { /* fila cheia: capacidade esgotada */
printf("Capacidade da fila estourou.\n");
exit(1); /* aborta programa */
}
/* insere elemento na próxima posição livre */
fim = (f->ini + f->n) % N;
f->vet[fim] = v;
f->n++;
}

2.3.5. Função fila_retira

Retira o elemento do início da fila, retornando o seu valor e verifica se a fila
está ou não vazia. Exemplo:
float fila _ retira (Fila* f)
{ float v;
if (fila_vazia(f)) {
printf("Fila vazia.\n");
exit(1); /* aborta programa */
}
/* retira elemento do início */
v = f->vet[f->ini];
f->ini = (f->ini + 1) % N;
f->n--;
return v;
}
 9

3. Código fonte

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

struct Node{
int num;
struct Node *prox;
};
typedef struct Node node;

int tam;

int menu(void);
void opcao(node *FILA, int op);
void inicia(node *FILA);
int vazia(node *FILA);
node *aloca();
void insere(node *FILA);
node *retira(node *FILA);
void exibe(node *FILA);
void libera(node *FILA);

int main(void)
{
node *FILA = (node *) malloc(sizeof(node));
if(!FILA){
printf("Sem memoria disponivel!\n");
exit(1);
}else{
inicia(FILA);
int opt;

do{
opt=menu();
opcao(FILA,opt);
}while(opt);

free(FILA);
return 0;
}
}

int menu(void)
{
int opt;

printf("Escolha a opcao\n");
printf("0. Sair\n");
printf("1. Zerar fila\n");
printf("2. Exibir fila\n");
printf("3. Adicionar Elemento na Fila\n");
printf("4. Retirar Elemento da Fila\n");
printf("Opcao: "); scanf("%d", &opt);

return opt;
}
 10

void opcao(node *FILA, int op)

{
node *tmp;
switch(op){
case 0:
libera(FILA);
break;

case 1:
libera(FILA);
inicia(FILA);
break;

case 2:
exibe(FILA);
break;

case 3:
insere(FILA);
break;

case 4:
tmp= retira(FILA);
if(tmp != NULL){
printf("Retirado: %3d\n\n", tmp->num);
free(tmp);
}
break;

default:
printf("Comando invalido\n\n");
}
}

void inicia(node *FILA)

{
FILA->prox = NULL;
tam=0;
}

int vazia(node *FILA)

{
if(FILA->prox == NULL)
return 1;
else
return 0;
}

node *aloca()
{
node *novo=(node *) malloc(sizeof(node));
if(!novo){
printf("Sem memoria disponivel!\n");
exit(1);
}else{
printf("Novo elemento: "); scanf("%d", &novo->num);
return novo;
}
}
 11

void insere(node *FILA)

{
node *novo=aloca();
novo->prox = NULL;

if(vazia(FILA))
FILA->prox=novo;
else{
node *tmp = FILA->prox;

while(tmp->prox != NULL)
tmp = tmp->prox;

tmp->prox = novo;
}
tam++;
}

node *retira(node *FILA)

{
if(FILA->prox == NULL){
printf("Fila ja esta vazia\n");
return NULL;
}else{
node *tmp = FILA->prox;
FILA->prox = tmp->prox;
tam--;
return tmp;
}

void exibe(node *FILA)

{
if(vazia(FILA)){
printf("Fila vazia!\n\n");
return ;
}

node *tmp;
tmp = FILA->prox;
printf("Fila :");
while( tmp != NULL){
printf("%5d", tmp->num);
tmp = tmp->prox;
}
printf("\n ");
int count;
for(count=0 ; count < tam ; count++)
printf(" ^ ");
printf("\nOrdem:");
for(count=0 ; count < tam ; count++)
printf("%5d", count+1);

printf("\n\n");
}

void libera(node *FILA)

 12

{
if(!vazia(FILA)){
node *proxNode,
*atual;

atual = FILA->prox;
while(atual != NULL){
proxNode = atual->prox;
free(atual);
atual = proxNode;
}
}

}
 13

3. CONCLUSÃO

Sendo assim, conclui-se que uma fila é uma estrutura de dados dinâmica que
admite remoção de elementos e inserção de novos objetos. Mais especificamente,
uma fila é uma estrutura sujeita à seguinte regra de operação: sempre que houver
uma remoção, o elemento removido é o que está na estrutura há mais tempo.
Em outras palavras, o primeiro objeto inserido na fila é também o primeiro a
ser removido. Essa política é conhecida pela sigla FIFO (First-In-First-Out).
Na resolução de um problema por meio de um programa, a primeira
providência é conceber um algoritmo adequado. A eficiência de um algoritmo
qualquer está intimamente relacionada à disposição, na memória, dos dados que
são tratados pelo programa.
 14

4. REFERENCIAS

-Estrututa de Dados - Fila

https://pt.slideshare.net/adrianots/estrutura-de-dados-filas

https://www.caelum.com.br/apostila-java-estrutura-dados/filas/

http://homepages.dcc.ufmg.br/~cunha/teaching/20121/aeds2/lists.pdf

https://pt.wikibooks.org/wiki/Algoritmos_e_Estruturas_de_Dados/Filas

https://www.ime.usp.br/~pf/algoritmos/aulas/fila.html

http://usuarios.upf.br/~mcpinto/ed-tsi/ed_parte01.pdf

Waldemar Celes, Renato Cerqueira, José Lucas Rangel, Introdução a

Estruturas de Dados, Editora Campus (2004) Capítulo 12 – Filas.