Você está na página 1de 33

UNIVERSIDADE ANHANGUERA - UNIDERP

TECNOLOGIA EM ANLISE DE DESENVOLVIMENTO DE SISTEMAS


PROGRAMAO ESTRUTURADA II

FABIO ARLINDO BERTOLINI. RA 7599630730


FELIPE MANZATTO RA 7982706922
CLAUDEVAN DIAS RA 6787394480
DANIEL PAULO ALVES DA SILVA RA 718894706
THIAGO ITO SIMO RA 6575299373

ATIVIDADE AVALIATIVA ATPS

TUTOR DISTNCIA PROFESSOR: MSC. EDILENE A. VENERUCHI DE CAMPOS.

JUNDIAI, 06 DE NOVEMBRO DE 2014


1

Resumo
Ser apresentada uma soluo computacional baseada em Estruturas de Dados para uma
empresa area chamada VOEBEM que deseja automatizar alguns processos adotados pela
companhia. A empresa necessita de um sistema que permita controlar a lista de vos,
dirios e de passageiros por vos, realizar a reserva de assentos e liberao para
taxiamento das aeronaves, realizar o controle de armazenamento das bagagens no
compartimento de carga e realizar levantamento das rotas de vos.

Sumrio

1. Introduo......................................................................................................................

04

ETAPA1: (Cdigo fonte)Relatrio 1 - Estrutura de Dados

05

1.1. Passo 1 .......................................................................................................................

05

1.2. Passo 2 .......................................................................................................................

05

1.3. Passo 3 .......................................................................................................................

05

ETAPA 2: (Cdigo fonte) Relatrio 2 - Listas Ligadas

08

2.1. Passo 1 ........................................................................................................................

08

2.2. Passo 2 ........................................................................................................................

08

2.3. Passo 3 ........................................................................................................................

08

ETAPA 3: (Cdigo fonte) Relatrio 3 - Filas e Pilhas com


14
3.1. Passo 1 ........................................................................................................................

14

3.2. Passo 2 ........................................................................................................................

14

3.3 Passo 3 .........................................................................................................................

15

ETAPA 4: (Cdigo fonte) Relatrio 4 - Grafos,...............................................................


4.1. Passo 1 ........................................................................................................................

18

4.2. Passo 2 .......................................................................................................................

21

4.3. Passo 3 .......................................................................................................................

22

6 Bibliografia.....................................................................................................................

22

1 Introduo
Muitos programas de computador do tipo Console so utilizados todos os dias. Para
a plataforma Linux, esta uma afirmao quase que incorporada estrutura do prprio
Sistema Operacional (SO). No SO Windows, os aplicativos de console, que so simples em
interface, mas que desempenham tarefas muitas vezes sofisticadas. Pode-se citar desde
programas de linha de comando como ipconfig que auxilia na visualizao das
configuraes de rede de um PC, at programas como o taskkill que auxiliam o usurio a
eliminar processos ativos na memria do computador.
O objetivo desta atividade adquirir experincia com o ciclo completo de
desenvolvimento de um pequeno aplicativo de linha de comando (Console).
Sendo assim, esta atividade concentra esforos no desenvolvimento de um programa
que permita contar linhas de cdigo fonte desenvolvida em Linguagem C ou C++ e a
estrutura sugerida permitir a sua adequao para outras linguagens.

ETAPA 1
Passo1
1. Fazer a leitura sobre: Introduo s Estruturas de Dados no livro texto da disciplina de
Estrutura de Dados, referenciado ao final dessa atividade, focando a leitura em Vetores
em C e implementao de Estruturas em C.
2. Fazer a leitura do material de aula: Vetores e Matrizes. Disponvel em:
<https://docs.google.com/open?id=0B_uLQd5hdqlWcnBnQVk0YVpTUXFzUmMyc1N
WaVpvQQ>. Acesso em: 27 mai. 2014. Buscar compreender o conceito de Alocao
Esttica de Memria que faz a utilizao de Vetores e Matrizes.
Passo 2
Fazer a discusso do contedo de texto e da aula lida, que ser utilizado para produzir
relatrio e implementao de uma estrutura, com destaque para:
1. alocao de Memria;
2. ponteiros em C;
3. estruturas de dados e C;
4. vetores em C;
5. implementando vetores unidimensionais;
6. operaes com strings de caracteres;
7. estruturas em C;
8. implementando estruturas.
Passos 3
1. Descrever e exemplificar o que alocao esttica de memria.
R: Alocao de memria, em cincia da computao, consiste no processo de
solicitar/utilizar memria durante o processo de execuo de um programa de computador.
Alocao Esttica: os dados tem um tamanho fixo e esto organizados seqencialmente na
memria do computador. Um exemplo tpico de alocao esttica so as variveis globais e
arrays;
AlocaoDinmica: os dados no precisam ter um tamanho fixo, pois podemos definir para cada
dado quanto de memria que desejamos usar. Sendo assim vamos alocar espaos de memria
(blocos) que no precisam estar necessariamente organizados de maneira seqencial, podendo
estar distribudos de forma dispersa (no ordenada) na memria do computador. Na alocao
dinmica, vamos pedir para alocar/desalocar blocos de memria, de acordo com a nossa
necessidade, reservando ou liberando blocos de memria durante a execuo de um programa.
Para poder achar os blocos que esto dispersos ou espalhados na memria usamos as variveis
do tipo Ponteiro (indicadores de endereos de memria).
5

Passo 4
2. Fazer um programa em Linguagem C que implemente uma estrutura avio(structaviao),
permitindo o cadastro e a exibio, com os seguintes campos:

#include<stdio.h>
#include<stdlib.h>
//Definindo Estrutura
struct aviao{
char modelo[50],fabricante[50],motor[70];
int passageiros;
char comprimento[60],altura[60],velocidade[40],altitude [40];
};
main(){
/*
Cada Campo (variavel) da struct pode ser acessada usando
operador "."
*/
struct aviao p[1];
int i;
for( i = 0 ; i<1 ; i++){
printf("Digite o Modelo :\n");
gets(p[i].modelo);
6

printf("Digite o Fabricante :\n");


gets(p[i].fabricante);
printf("Digite o Motor :\n");
gets(p[i].motor);
printf("Digite o Comprimento :\n");
gets(p[i].comprimento);
printf("Digite a altura :\n");
gets(p[i].altura);
printf("Digite a velocidade :\n");
gets(p[i].velocidade);
printf("Digite a altitude :\n");
gets(p[i].altitude);
printf("Digite o numero de passageiros Comportados\n");
scanf("%d\n",&p[i].passageiros);
};
int barras;
for(barras = 0 ; barras < 3 ; barras++){
printf("\\\\\\\\\\\\\\\\\\\\\\/////////////////// \n");
barras++;
}
// Imprimindo Resultado
for(i = 0 ; i <1 ; i++){
printf("O modelo do Avio :%s\n",p[i].modelo);
printf("O Fabricante do Avio :%s\n",p[i].fabricante);
printf("O motor do Avio :%s\n",p[i].motor);
7

printf("O numero de passageiros comportado pelo Avio :%d\n",p[i].passageiros);


printf("O comprimento do Avio :%s\n",p[i].comprimento);
printf("A altura mxima do Avio :%s\n",p[i].altura);
printf("A velocidade mxima do avio : %s\n",p[i].velocidade);
printf("A altitude mxima do Avio :%s\n",p[i].altitude);
}
system("PAUSE");
return 0;
}

ETAPA 2
Passo 1 (individual)
1. Fazer a leitura do material de aula: Alocao Dinmica de Memria. Disponvel em:
<https://docs.google.com/open?id=0B_uLQd5hdqlWTVFzdzZRYTZSSDJRRm9hLVg1Rj
RxZw>. Acesso em: 27 mai. 2014. Focar a leitura no funcionamento da alocao dinmica
de memria, funo malloc() e funo free().
2. Fazer a leitura sobre: Filas e Listas no livro texto da disciplina de Estrutura de Dados,
focando a leitura na implementao de Listas Ligadas.
3. Fazer a leitura do material de aula: Lista Simplesmente Encadeada. Disponvel em:
<https://docs.google.com/open?id=0B_uLQd5hdqlWQXdYT19jQUJUd2Vob1BYQ3dWZ
Ekydw>. Acesso em: 27 ma1. 2014. Focar a leitura na implementao de listas
simplesmente encadeada.

Passo 2 (Equipe)
1. Fazer um programa em Linguagem C que criem uma estrutura de dados voo(struct voo)
para a empresa VOEBEM, que servir para implementar funes para controle da lista
dos voos. A estrutura voo deve ser implementada de forma dinmica e deve conter os
seguintes dados:
nmero do voo;

2. Implementar a funo cadastrarVoo() que deve permitir o cadastro de um novo voo;


3. Implementar a funo consultaVoo() que deve permitir obter as informaes do voo com
base na digitao do nmero do voo;
4. Implementar a funo removeVoo() que permita a excluso de um determinado voo.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
enum boolean {
true = 1, false = 0
9

};
typedef enum boolean bool;
struct Voo {
int numvoo ;
char datvoo ;
char horvoo ;
char aersaida ;
char aerchegada ;
char rota ;
char tempvoo ;
char pasabordo ;
struct Voo *prox;
};
struct Voo *aux, *inicio = NULL, *final = NULL;
struct Voo* cria(void)
{
return NULL;
}
struct Voo* insere()
{
char dtvoo;
char hrvoo,rt;
char arsaida,archegada;
char tpvoo,pasbordo;
int nv;
10

fflush(stdin);
printf("Digite o numero do voo: \n");
scanf("%d",&nv);
printf("Digite a data do voo: \n");
scanf("%s",&dtvoo);
printf("Digite o horario do voo: \n");
fflush(stdin);
scanf("%s",&hrvoo);
printf("Digite o Aeroporto de saida: \n");
fflush(stdin);
scanf("%s",&arsaida);
printf("Digite o Aeroporto de chegada: \n");
fflush(stdin);
scanf("%s",&archegada);
printf("Digite a rota: \n");
fflush(stdin);
scanf("%s",&rt);
printf ("Digite o tempo estimado de voo: \n");
fflush(stdin);
scanf("%s",&tpvoo);
printf ("Passageiros a bordo: \n");
fflush(stdin);
scanf ("%s",&pasbordo);
aux = (struct Voo*) malloc (sizeof(struct Voo));
aux->numvoo=nv;
11

aux->datvoo=dtvoo;
aux->horvoo=hrvoo;
aux->aersaida=arsaida;
aux->aerchegada=archegada;
aux->rota=rt;
aux->tempvoo=tpvoo;
aux->pasabordo=pasbordo;
aux -> prox = (struct Voo *) NULL;
if(inicio == NULL)
inicio = final = aux;
else
{
final -> prox = aux;
final = aux;
}
return inicio;
}
int lista_vazia(struct Voo *lista)
{
if(lista == NULL)
return 1;
else
return 0;
}
void visualiza_lista (struct Voo *lista)
12

{
if(!lista_vazia(lista))
{
aux = lista;
while(aux != (struct Voo *) NULL)
{
printf("Voo: %i\n", aux->numvoo);
printf("Data do Voo: %s\n", aux->datvoo);
printf("Horario do Voo: %s\n", aux->horvoo);
printf("Aeroporto de saida: %s\n", aux->aersaida);
printf("Aeropotyo de chegada: %s\n", aux->aerchegada);
printf("Rota: %s\n", aux->rota);
printf("Tempo de Voo:%s\n",aux->tempvoo);
printf("Numero de passageiros:%s\n",aux->pasabordo);
aux = aux -> prox;
}
}
else
printf("\nSem Voos marcados!");
getch();
}
struct Voo* busca(struct Voo* lista, int busca)
{
bool achou = 0;
if(!lista_vazia(lista))
13

{
for(aux=lista;aux!=NULL;aux=aux->prox)
if(aux->numvoo == busca)
{
printf("Voo encontrado: \n");
printf("Voo: %i\n", aux->numvoo);
printf("Data do Voo: %s\n", aux->datvoo);
printf("Horario do Voo: %s\n", aux->horvoo);
printf("Aeroporto de saida: %s\n", aux->aersaida);
printf("Aeropotyo de chegada: %s\n", aux->aerchegada);
printf("Rota: %s\n", aux->rota);
printf("Tempo de Voo:%s\n",aux->tempvoo);
printf("Numero de passageiros:%s\n",aux->pasabordo);
achou = 1;
}
if(!achou)
printf("Voo no encontrado !\n");
}
else
{
printf("\nNao a Voos marcados.");
}
getch();
return NULL;
}
14

struct Voo* excluir(struct Voo *lista, char numvoo)


{
struct Voo *ant = NULL;
aux = lista;
if(!lista_vazia(lista))
{
while(aux!= NULL && aux->numvoo != numvoo)
{
ant = aux;
aux = aux->prox;
}
if(aux == NULL)
{
printf("\nNao foi possivel a exclusao. Voo nao encontrado!");
getche();
return lista;
}
if(ant == NULL)
lista = aux->prox;
else
ant->prox = aux->prox;
free(aux);
printf("Voo removido com sucesso!\n");
getche();
return lista;
15

}
else
{
printf("\nTentou remover um Voo inexistente.");
getche();
return lista;
}
}
int main(int argc, char *argv[])
{
int op, vremover, vbuscar;
struct Voo *lista;
lista = cria();
printf ("\t\t** Sistema de Voo **\n\n");
while(op != 5)
{
system("cls");
printf ("\t\t* Sistema de Voo *\n\n");
printf("\nPrograma Para Manipulacao Dados do Voo ");
printf("\n1 - Adicionar Voo");
printf("\n2 - Visualizar Voos");
printf("\n3 - Buscar Voo");
printf("\n4 - Excluir Voo");
printf("\n5 - Sair do Programa");
printf("\nEntre com a Opcao Desejada: ");
16

scanf("%i",&op);
switch(op)
{
case 1:
lista = cria();
lista = insere();
break;
case 2: visualiza_lista(lista);
break;
case 3:
printf("Entre com o Voo que deseja buscar: ");
scanf("%d",&vbuscar);
busca(lista,vbuscar);
break;
case 4:
printf("Entre com o Voo que deseja remover: ");
scanf("%i",&vremover);
lista = excluir(lista, vremover);
break;
case 5: exit(1);
}
}
}

Passo 3 (Equipe)
1. Fazer um programa em Linguagem C que implemente a estrutura passagem (struct
passagem) para a empresa VOEBEM que servir para implementar funes para controle
da lista de passagens areas vendidas. A estrutura passagem deve ser implementada de
17

forma dinmica e deve conter os seguintes dados:

Embarque;

2. Implementar a funo cadastrarPassagem() que deve permitir o cadastro de uma nova


passagem;
3. Implementar a funo consultaPassagem() que deve permitir obter informaes sobre a
passagem com base na digitao do nmero da passagem.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
enum boolean
{
true = 1, false = 0
};
typedef enum boolean bool;
struct passagem {
int numpass ;
int numvoo ;
int dtembarque ;
int hrembarque ;
int portaoembarque ;
struct passagem *prox;
};
struct passagem *aux, *inicio = NULL, *final = NULL;
struct passagem* cria(void)
{
18

return NULL;
}
struct passagem* CadastraPassagem()
{
int dtvoo;
int npass;
int nvoo;
int hembar;
int portaoembar;
fflush(stdin);
printf("Digite o numero da passagem: \n");
scanf("%d",&npass);
printf("Digite o numero do Voo: \n");
scanf("%d",&nvoo);
printf("Digite a data do voo: \n");
scanf("%s",&dtvoo);
printf("Digite o horario do embarque: \n");
fflush(stdin);
scanf("%s",&hembar);
printf("Digite o porto de embarque: \n");
fflush(stdin);
scanf("%s",&portaoembar);
aux = (struct passagem*) malloc (sizeof(struct passagem));
aux->numpass=npass;
aux->numvoo=nvoo;
19

aux->dtembarque=dtvoo;
aux->hrembarque=hembar;
aux->portaoembarque=portaoembar;
aux -> prox = (struct passagem *) NULL;
if(inicio == NULL)
inicio = final = aux;
else
{
final -> prox = aux;
final = aux;
}
return inicio;
}
int lista_vazia(struct passagem *lista)
{
if(lista == NULL)
return 1;
else
return 0;
}
struct Voo* busca(struct passagem* lista, int busca)
{
bool achou = 0;
if(!lista_vazia(lista))
{
20

for(aux=lista;aux!=NULL;aux=aux->prox)
if(aux->numpass == busca)
{
int numpass ;
int numvoo ;
int dtembarque ;
int hrembarque ;
int portaoembarque ;
printf("Passagem: \n");
printf("Passagem: %i\n", aux->numpass);
printf("Voo: %i\n", aux->numvoo);
printf("Data de embarque: %s\n", aux->dtembarque);
printf("Hora do embarque: %s\n", aux->hrembarque);
printf("Aeroporto de saida: %s\n", aux->portaoembarque);
achou = 1;
}
if(!achou)
printf("Passagem nao encontrada !\n");
}
else
{
printf("\nA passagem nao foi marcados.");
}
getch();
return NULL;
21

}
int main(int argc, char *argv[])
{
int op, vbuscar;
struct passagem *lista;
lista = cria();
printf ("\t\t** Passagens **\n\n");
while(op != 3)
{
system("cls");
printf ("\t\t* Sistema de Passagens *\n\n");
printf("\nPrograma Para Manipulacao Dados do Voo ");
printf("\n1 - Adicionar Passagem");
printf("\n2 - Buscar Passagem");
printf("\n3 - Sair do Programa");
printf("\nEntre com a Opcao Desejada: ");
scanf("%i",&op);
switch(op)
{
case 1:
lista = cria();
lista = CadastraPassagem();
break;
case 2:
printf("Entre com a passagem que deseja buscar: ");
22

scanf("%d",&vbuscar);
busca(lista,vbuscar);
break;
case 3: exit(1);
}
}
}

ETAPA 3
Passo 1 (Individual)
1. Fazer a leitura sobre: Filas e Listas no livro texto da disciplina de Estrutura de Dados,
focando a leitura na implementao de Filas em C.
2. Fazer a leitura sobre: A Pilha no livro texto da disciplina de Estrutura de Dados, focando
a leitura na implementao de Pilhas em C.
3. Fazer a leitura do material de aula: Pilhas. Disponvel em:
<https://docs.google.com/open?id=0B_uLQd5hdqlWUVV6N0FxbzdRZm1KT0d2Y282b
U1Zdw>. Acesso em: 27 mai. 2014. Focar a leitura na implementao de pilhas.
Passo 2 (Equipe)
1. Fazer um programa em Linguagem C que implemente a estrutura taxiamento
(structtaxiamento) para controlar a Liberao para Taxiamento das Aeronaves para
decolagem na pista de voos. O taxiamento e as decolagens devem obedecer uma fila para
no haver choques entre as aeronaves a decolar e que esto pousando. A estrutura
taxiamento deve ser implementada de forma dinmica e deve conter as seguintes
informaes:

23

2. Implementar a funo cadastrarTaxiamento() que deve cadastras as informaes do


taxiamento e decolagem com as informaes acima. O cadastro deve obedecer disciplina
de insero dos dados FIFO (First In First Out).
3. Implementar a funo autorizaTaxiamento() que deve apresentar qual a sequencia de
taxiamentos e decolagens das aeronaves.
struct taxiamento
{
int numeroVoo;
int horarioSaida;
char modeloAeronave[10];
char empresaAerea[10];
struct taxiamento * prox; // ponteiro para o prximo
};
int main (int argc, char *argv[])
{
struct taxiamento * inicio = NULL,*fim,*novo,*aux,*imprime; // ponteiro para a struct voo
int opcao = 0;
// enquanto for de 3
while(opcao != 3)
{
printf("\n");
printf("[1] Cadastrar Taxiamento\n");
printf("[2] Ordem de Autorizacao de Taxiamento \n");
printf("[3] Sair \n");
scanf("%d", &opcao);
if(opcao == 1)
{
// aloca memria
novo = (struct taxiamento*)malloc(sizeof(struct taxiamento));
// atualiza fim do ponteiro
novo->prox = (struct taxiamento*)NULL;
printf("\n");
printf("Digite o numero do voo: ");
scanf("%d", &novo->numeroVoo);
printf("Modelo da aeronave: ");
scanf("%s", &novo->modeloAeronave);
printf("Empresa Aerea: ");
scanf("%s", &novo->empresaAerea);
24

printf("Horario de Saida: ");


scanf("%d", &novo->horarioSaida);
if(inicio==(struct taxiamento *)NULL)
{
inicio = novo;
fim = inicio;
}

else
{
//atribuindo o apontamento do ultimo registro para o novo
fim->prox = novo;
//apontando o ultimo registro como fim
fim = novo;
}
}

else if(opcao == 2)
{
// proximo_voo->prox = NULL;
// proximo_ponto aponta para o mesmo de ini_ponto, comea do incio
imprime = inicio;
printf("\n");
// mostra todos os dados
// enquanto proximo_ponto for diferente de NULL
while(imprime != NULL)
{
printf(" Ordem de decolagem: \n Voo n.: %d, Modelo Aeronave: %s, Empresa Aerea: %s, Horario de
Saida: %d\n", imprime->numeroVoo, imprime->modeloAeronave,imprime->empresaAerea, imprime> horarioSaida);
imprime = imprime->prox; // aponta para o prximo
}
}
}
/*
O prximo NULL porque s sabemos que uma lista encadeada chegou
ao fim quando o prximo elemento aponta para NULL
*/
25

return 0;
};

Passo 3 (Equipe)
1. Fazer um programa em Linguagem C que implemente a estrutura bagagem (struct
bagagem) para o controle de armazenamento das bagagens no compartimento de cargas.
O programa deve controlar o empilhamento e desempilhamento das bagagens e ser
implementado de forma dinmica, por meio das seguintes informaes:

barque;
2. Implementara funo cadastraBagagem() que deve permitir o cadastro de bagagens dos
passageiros. O cadastro deve obedecer disciplina de insero dos dados LIFO (Last In
First Out).
3. Implementar a funo recuperaBagagem() que deve resgatar as bagagens que foram
empilhadas pela funo cadastraBagagem().
// estrutura bagagem
struct bagagem
{
int codigoBag;
int numeroPassagem;
int numeroVoo;
int dataEmbarque;
int horaEmbarque;
int portaoEmbarque;
struct bagagem* prox; // ponteiro para o prximo
};
int main (int argc, char *argv[])
{
struct bagagem* inicio = NULL,*fim, *novo,*aux,*imprime; // ponteiro para a struct voo
int opcao = 0;
// enquanto for de 3
while(opcao != 3)
{
printf("\n");
printf("[1] Cadastrar Bagagem \n");
printf("[2] Recuperar Bagagem \n");
26

printf("[3] Sair \n");


scanf("%d", &opcao);
if(opcao == 1)
{
// aloca memria
novo = (struct bagagem*)malloc(sizeof(struct bagagem));
// atualiza fim do ponteiro
novo->prox = (struct bagagem*)NULL;
printf("\n");
printf("Digite codigo dabagagem: ");
scanf("%d", &novo->codigoBag);
printf("Digite o numero da passagem: ");
scanf("%d", &novo->numeroPassagem);
printf("Digite o numero do Voo: ");
scanf("%d", &novo->numeroVoo);
printf("Data do embarque: ");
scanf("%d", &novo->dataEmbarque);
printf("Horario de Embarque: ");
scanf("%d", &novo->horaEmbarque);
printf("Portao de embarque: ");
scanf("%d", &novo->portaoEmbarque);
if(inicio==(struct bagagem*)NULL)
{
inicio = novo;
fim = inicio;
}

else
{
//atribuindo o apontamento do primeiro registro para o ultimo da pilha
novo->prox = inicio;
//apontando o novo registro para o primeiro da pilha
inicio = novo;
}
}

else if(opcao == 2)
{
// proximo_voo->prox = NULL;
// proximo_ponto aponta para o mesmo de ini_ponto, comea do incio
imprime = inicio;
printf("\n");
// mostra todos os dados
27

// enquanto proximo_ponto for diferente de NULL


while(imprime != NULL)
{
printf(" Recuperar bagagem :\n Codigo: %d, Numero da Passagem: %d, Numero do Voo: %d, Data de
Embarque: %d, Horario de Embarque: %d, Portao de Embarque: %d \n", imprime->codigoBag,
imprime->numeroPassagem,imprime->numeroVoo, imprime-> dataEmbarque, imprime>horaEmbarque, imprime->portaoEmbarque);
imprime = imprime->prox; // aponta para o prximo
}
}
}
/*
O prximo NULL porque s sabemos que uma lista encadeada chegou
ao fim quando o prximo elemento aponta para NULL
*/
return 0;
};

ETAPA 4
Passo 1 (Individual)
1. Fazer a leitura: Grafos e Suas Aplicaes no livro texto da disciplina de Estrutura de
Dados, focando a leitura na aplicao e representaes de Grafos em C.
2. Fazer a leitura do material de aula: Grafos e Suas Aplicaes. Disponvel em:
<https://docs.google.com/open?id=0B_uLQd5hdqlWdU9tQi1yS1pTQXUzNEQ1d3Bsbk
ZBUQ>. Acesso em: 27 mai. 2014. Focar a leitura na implementao de filas.
Passo 2 (Equipe)
Fazer a discusso da leitura do captulo do livro texto e do material de aula, que ser
utilizado como base para a implementao de rotas de voos por meio da estrutura grafo,
com
destaque para:
1. Representao de Grafos em C.
2. Algoritmo de Menor Caminho.
3. Representao por meio de Matriz de Adjacncia.
4. Caminhamento em Amplitude.
5. Caminhamento em Profundidade.

Passo 3 (Equipe)
1. Fazer um programa em Linguagem C que implemente um levantamento de rotas entre
uma Cidade A e uma Cidade B por meio de um Grafo, utilizando Matriz de Adjacncia.
Considerar um total de dez cidades e fazer a ligao entre elas considerando as distncias
e tempo voo. Para percorrer da Cidade A para a Cidade B, considerar como melhor opo
a distncia e o tempo de voo. A Figura 1 apresentada a seguir, representa um mapa de
28

rotas de voos de cidades brasileiras. Considerar, por exemplo, o deslocamento entre a


cidade de Belo Horizonte Fortaleza. Podem-se considerar as seguintes rotas de voos:
1. Belo Horizonte Fortaleza.
2. Belo Horizonte So Lus Fortaleza.
3. Belo Horizonte Recife Fortaleza.
4. Belo Horizonte Salvador Recife Fortaleza.
void zerarVariaveis();
void montarGrafo();
void verificarAdjacencia();
void imprimirMatriz();
void comecarDeNovo();
int retornaIndice(char nome[30]);
void insereNoVetor(char nome[30]);
void caminhamentoAmplitude();
void caminhamentoProfundidade();
int pegaVerticeAdjNaoVisitado(int indice);
void zeraAsVisitas();
void insereNaFila(int indice);
int filaVazia();
int removeDaFila();
void push(int indice);
int pop();
int pilhaVazia();

//definio da estrutura de dados e das variaveis globais0


#define MAXNOS 10
#define PARES 5

int matriz[MAXNOS][MAXNOS];
struct no
{
29

int visitado;
char descricao[30];
};struct no vetor[MAXNOS];
int quantosNos;

struct pilha
{
int vetor[MAXNOS]; //MAXNOS + 1 para evitar de causar overflow
int topo;
};
struct pilha p;

struct fila
{
int vetor[MAXNOS]; //MAXNOS + 1 para evitar de causar overflow
int inicio, fim, quantos;
};
struct fila f;

void push(int indice)


{
if (p.topo == MAXNOS)
puts ("Pau Geral de Overflow na Pilha");
else
{
p.topo++;
p.vetor[p.topo] = indice;
}
}//push

30

int pop()
{
int indice = -1;
if (p.topo == -1)
puts ("Pau Geral de Underflow na Pilha");
else
{
indice = p.vetor[p.topo];
p.topo--;
}
return (indice);
}//pop

int pilhaVazia()
{
int vazio = 1;
if (p.topo > -1)
vazio = 0;
return vazio;
}

void insereNaFila(int indice)


{
if (f.quantos == MAXNOS)
puts ("Pau Geral de Overflow na Fila");
else
{
if (f.fim == (MAXNOS-1))
f.fim = 0;
else
31

f.fim++;
f.vetor[f.fim] = indice;
f.quantos++;
}
}

int filaVazia()
{
int vazio = 1;
if (f.quantos > 0)
vazio = 0;
return vazio;
}

int removeDaFila()
{
int indice = -1;
if (f.quantos == 0)
puts ("Pau Geral de Underflow na Fila");
else
{
indice = f.vetor[f.inicio];
f.quantos--;
if (f.inicio == (MAXNOS-1))
f.inicio = 0;
else
f.inicio++;
}
return (indice);
}
32

void zerarVariaveis()
{
int i, j;
p.topo = -1;
f.inicio = f.quantos = 0;
f.fim = -1;
quantosNos = -1;
for (i = 0; i < MAXNOS; i++)
{
for (j = 0; j < MAXNOS; j++)
matriz[i][j] = 0;
vetor[i].visitado = 0;
strcpy(vetor[i].descricao, " ");
}
}

int pegaVerticeAdjNaoVisitado(int indice)


{
int coluna, retorna = -1;
for (coluna = 0; coluna

33