VALPARASO DE GOIS / GO

RELATRIO 01 Estrutura de Dados

Como podemos acompanhar na leitura dos textos propostos, chegamos a algumas
concluses sobre determinados temas discutidos na matria.Alocao de memria nada mais
do que o processo de reservar (utilizar) um espao de pode ser esttica ou dinmica, pendendo
1

das necessidades do programa.Ponteiros em C, so variveis que tem como valor o endereo e

memria de outras variveis, ele utilizado para fazer referencia ao endereo nele contido.
Estruturas quando se pensa em estruturas, voc est pensando em um tipo de varivel
(ou dado) que guarde consigo vrios tipos de informaes relacionadas. Ou seja um
dado do tipo calendrio, que possa ser capaz de armazenar dias, meses e anos em
formato Inteiro, e tambm o nome dos meses e dias da semana em formato String.
Na prtica voc cria uma referencia a uma estrutura, e dentro dela voc ter as
variveis de tipo primitivo que guardaro as informaes inerentes aquele tipo de dado.
Vetores nada mais so do que uma sequencia de vrios valores de um mesmo tipo, por
exemplo do tipo inteiro. A ideia se usar os vetores toda vez que voc tiver que guardar
uma sequencia de informaes de um mesmo tipo, ao invs de se declarar inmeras
variveis para armazenar os valores, voc cria um vetor e armazena suas informaes
dentro deste vetor.Strings de caracteres, so vetores do tipo char, que so usados para guardar
uma cadeia de caracteres, que podem formar palavras ou textos.
O ultimo caractere de uma string o caractere especial \0, que indica para o programa
que a string acabou, mesmo que o vetor contenha espao para mais caracteres. Na biblioteca
String.h, existem vrias funes para o tratamento das string, funes que vo desde retornar
o tamanho da string, copiar o contedo da string A para a string B, como tambm converter
uma string, em inteiro ou float, entre outros.Alocao Esttica de Memria
A alocao de memria, o processo no qual o programa solicita o uso de memria ao
Sistema Operacional. Na alocao esttica de memria, na hora da compilao o
programa j sabe quanto de espao que ser utilizado pelas variveis. Desta forma, no
possvel alterar o tamanho deste espao durante a execuo do programa.
disso um simples programinha que retorna a soma de dois inteiros, levando em conta
que as nicas variveis utilizadas pelo programa seriam 3 variveis do tipo inteiro (duas
para armazenar os valores dos operandos e uma para armazenar o resultado), o
programa reservaria de forma esttica 12 bytes (cada inteiro ocupa 4 bytes).
Passo 03_Avio
#include<stdio.h>
#include<stdlib.h>
//Definindo Estrutura
2

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);
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
3

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

Descrio Como foi proposto no passo 3 da 1 etapa, foi desenvolvido um programa

em C, que implementasse uma estrutura nominada avio, com os seguintes campos: Modelo,
Fabricante,

Passageiros,

Comprimento,

Altura,

Velocidade,

Altitude,

Motor.

RELATORIO 02 Listas Ligadas

A alocao dinmica o processo que aloca memria em tempo de execuo. Ela
utilizada quando no se sabe ao certo quanto de memria ser necessrio para o
armazenamento das informaes, podendo ser determinadas em tempo de execuo conforme
a necessidade do programa. Dessa forma evita-se o desperdcio de memria.
No padro C ANSI existem 4 funes para alocaes dinmica pertencentes a
biblioteca stdlib.h. So elas malloc(), calloc(), realloc() e free(). Sendo que as mais utilizadas
so as funes malloc() e free().
A alocao dinmica muito utilizada em problemas de estrutura de dados, por
exemplo, listas encadeadas, pilhas, filas, arvores binrias e grafos. As funes malloc() e
calloc() so responsveis por alocar memria, a realloc() por realocar a memria e por ultimo
a free() fica responsvel por liberar a memria alocada.
Passo 02 e 03_ Estrutura de Voo e Passagem
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//---------------------------------------------------------------------------------struct Voo
{
int numerovoo;
char datavoo[50];
char horavoo[50];
char aeroportosaida[50];
char aeroportochegada[50];
char rota[50];
char tempodevoo[50];
int qtpassageiros;
struct Voo *prox;
};
5

//---------------------------------------------------------------------------------struct CADASTROSVOOS
{
struct Voo *inicio;
struct Voo *fim;
};
//---------------------------------------------------------------------------------struct Passagens
{
int numerovoo;
int numeropassagem;
char dataembarque[50];
char horaembarque[50];
char portaoembarque[50];
struct Passagens *prox;
};
//---------------------------------------------------------------------------------struct CADASTROSPASSAGENS
{
struct Passagens *iniciop;
struct Passagens *fimp;
};
//---------------------------------------------------------------------------------int passagemvazio(struct CADASTROSPASSAGENS *empp);
void construtorpassagem (struct CADASTROSPASSAGENS *empp);
int

cadastrarPassagem(struct

CADASTROSPASSAGENS

*empp,

struct

Passagens

passagens);
void consultarPassagem(struct CADASTROSPASSAGENS *empp, int numpassagem);
int voovazio(struct CADASTROSVOOS *emp);
void construtor (struct CADASTROSVOOS *emp);
6

int cadastrarVoo(struct CADASTROSVOOS *emp, struct Voo voo);

void consultarVoo(struct CADASTROSVOOS *emp, int numvoo);
int removeVoo(struct CADASTROSVOOS *emp);
//---------------------------------------------------------------------------------int main()
{
struct Voo v;
struct CADASTROSVOOS emp;
construtor(&emp);
struct Passagens vp;
struct CADASTROSPASSAGENS empp;
construtorpassagem(&empp);
int opcaomain;
int opcao;
int pesquvoo;
int pesqupass;
while(opcaomain !=9)
{
int opcaomain=0;
int opcao =0;
int pesquvoo=0;
int opcaopassagem=0;
int pesqupass=0;
printf("\n*** EMPRESA VOEBEM ***\n\n");
printf("Bem vindo\n\n");
printf("Menu:\n\n");
printf("1-Menu de cadastros de Voos;\n");
printf("2-Menu de cadastro de Passagens;\n");
printf("9-Sair\n");
//------------- Inicio Estrutura de verificacao
do{
7

printf("\nEntre com a escolha: ");

scanf("%d",&opcaomain);
if(opcaomain!=1 && opcaomain!= 2 && opcaomain!=9)
{
printf("Por favor, insira uma opcao valida.\n");
}
}while(opcaomain !=1 && opcaomain!= 2 && opcaomain!=9);
//------------- Fim Estrutura de verificacao
system("cls");
switch(opcaomain)
{
case 1:
while(opcao != 9)
{
printf("\n*** EMPRESA VOEBEM ***\n\n");
printf("Cadastro de Voos.\n\n");
printf("Menu:\n\n");
printf("1-Cadastrar Voo;\n");
printf("2-Consultar Voo;\n");
printf("3-Excluir Voo\n");
printf("9-Sair\n");
//------------- Inicio Estrutura de verificacao
do{
printf("\nEntre com a escolha: ");
scanf("%d",&opcao);
if(opcao!=1 && opcao!= 2&& opcao!= 3 && opcao!=9)
{
printf("Por favor, insira uma opcao valida.\n");
}
}while(opcao !=1 && opcao!= 2&& opcao!= 3 && opcao!=9);
//-------------Fim Estrutura de verificacao
8

switch(opcao)
{
case 1:
system("cls");
printf("------CADASTRO DE VOO------\n");
printf("Informe o numero do Voo:\n");
scanf("%d",&v.numerovoo);
fflush(stdin);
printf("\nInforme a data do voo: DD/MM/AAAA\n");
gets(v.datavoo);
printf("\nInforme a Hora do voo: HH:MM\n");
gets(v.horavoo);
printf("\nInforme aeroporto de saida\n");
gets(v.aeroportosaida);
printf("\nInforme o aeroporto Destino\n");
gets(v.aeroportochegada);
fflush(stdin);
printf("\nInforme a Rota\n");
gets(v.rota);
fflush(stdin);
printf("\nInforme o tempo de voo:\n");
gets(v.tempodevoo);
fflush(stdin);
printf("\nInforme o Numero de Passageiros:\n");
scanf("%d",&v.qtpassageiros);
cadastrarVoo(&emp,v);
system("cls");
break;
case 2:
system("cls");
printf("Qual numero de Voo deseja pesquisar?\n");
scanf("%d",&pesquvoo);
consultarVoo(&emp, pesquvoo);
9

system("cls");
break;
case 3:
if(removeVoo(&emp)==1)
{
printf("Primeiro Voo da lista removido com sucesso.\n");
system("pause");
}else
{
printf("FALHA!!!\n");
system("pause");
}
system("cls");
break;
case 9:
system("cls");
break;
default:
printf("opcao invalida, tente novamente\n");
system("pause");
system("cls");
break;
}
}
break;
case 2:
while(opcaopassagem != 9)
{
printf("\n*** EMPRESA VOEBEM ***\n\n");
printf("Cadastro de Passagens.\n\n");
printf("Menu:\n\n");
10

printf("1-Cadastrar Passagem;\n");
printf("2-Consultar Passagem;\n");
printf("9-Sair\n");
//------------- Inicio Estrutura de verificacao
do{
printf("\nEntre com a escolha: ");
scanf("%d",&opcaopassagem);
if(opcaopassagem!=1 && opcaopassagem!= 2 && opcaopassagem!=9)
{
printf("Por favor, insira uma opcao valida.\n");
}
}while(opcaopassagem !=1 && opcaopassagem!= 2 && opcaopassagem!=9);
//------------- Fim Estrutura de verificacao
switch(opcaopassagem)
{
case 1:
system("cls");
printf("------CADASTRO DE PASSAGENS------\n");
printf("Informe o numero do Voo:\n");
scanf("%d",&vp.numerovoo);
fflush(stdin);
printf("Informe o numero da Passagem:\n");
scanf("%d",&vp.numeropassagem);
fflush(stdin);
printf("\nInforme a data do embarque: DD/MM/AAAA\n");
gets(vp.dataembarque);
printf("\nInforme a Hora do embarque: HH:MM\n");
gets(vp.horaembarque);
printf("\nInforme o portao do embarque\n");
gets(vp.portaoembarque);
cadastrarPassagem(&empp,vp);
system("cls");
break;
11

case 2:
system("cls");
printf("Qual numero de Passagem deseja pesquisar?\n");
scanf("%d",&pesqupass);
consultarPassagem(&empp, pesqupass);
system("cls");
break;
case 9:
system("cls");
break;
default:
printf("opcao invalida, tente novamente\n");
system("pause");
system("cls");
break;
}
break;
case 9:
system("cls");
printf("\nPrograma finalizado\n.");

}
}
}
return 0;
}
//----------------------------------------------------------------------------------Inicio

estrutura

de

cadastros voos
void construtor (struct CADASTROSVOOS *emp)
{
12

emp->inicio=NULL;
emp->fim=NULL;
}
int voovazio(struct CADASTROSVOOS *emp)
{
if(emp->inicio==NULL)
{
return 1;
}else
{
return 0;
}
}
//---------------------------------------------------------------------------------int cadastrarVoo(struct CADASTROSVOOS *emp, struct Voo voo)
{
struct Voo *novovoo;
novovoo=(struct Voo*) malloc(sizeof(struct Voo));
if(novovoo!=NULL)
{
novovoo->numerovoo = voo.numerovoo;
strcpy(novovoo->datavoo, voo.datavoo);
strcpy(novovoo->horavoo, voo.horavoo);
strcpy(novovoo->aeroportosaida, voo.aeroportosaida);
strcpy(novovoo->aeroportochegada, voo.aeroportochegada);
strcpy(novovoo->rota, voo.rota);
strcpy(novovoo->tempodevoo,voo.tempodevoo);
novovoo->qtpassageiros = voo.qtpassageiros;
novovoo->prox=NULL;
if(voovazio(emp)>0)
{
emp->inicio=novovoo;
emp->fim=novovoo;
13

}
else
{
emp->fim->prox=novovoo;
emp->fim=novovoo;
}
}
printf("Voo Cadastrado com sucesso\n");
system("pause");
return 0;
}
//---------------------------------------------------------------------------------void consultarVoo(struct CADASTROSVOOS *emp, int numvoo)
{
struct Voo *v;
int verificador = 0;
v=emp->inicio;
if(emp->inicio== NULL)
{
printf("N??o existe Voo cadastrado.\n");
system("pause");
}else{
while(v!=NULL)
{
if (v->numerovoo==numvoo)
{
verificador = 1;
printf("--------------------------------------\n");
printf("Informacoes do Voo numero %d\n",v->numerovoo);
printf("Data:%s\n", v->datavoo);
printf("Hora: %s\n",v->horavoo);
printf("Aeroporto de Saida: %s\n",v->aeroportosaida);
printf("Aeroporto Destino: %s\n",v->aeroportochegada);
14

printf("Rota Utilizada: %s\n",v->rota);

printf("Tempo de Voo: %s\n",v->tempodevoo);
printf("Numero de Passageiros: %d\n",v->qtpassageiros);
printf("--------------------------------------\n");
}
v=v->prox;
}
if (verificador == 0)
{
printf("Nao existe Voo com este numero cadastrado, tente novamente\n");
}
system("pause");
system("cls");
}
}
//---------------------------------------------------------------------------------int removeVoo(struct CADASTROSVOOS *emp)
{
struct Voo *v;
if(voovazio(emp)==0)
{
v = emp->inicio;
emp->inicio = v->prox;
free(v);
if(emp->inicio==NULL)if(voovazio(emp)>0)
{
emp->fim=NULL;
}
}
return 1;
}
//----------------------------------------------------------------------------------Fim

estrtura

cadastrovoos
15

//----------------------------------------------------------------------------------Inicio

Estrutura

cadastropassaagens
void construtorpassagem (struct CADASTROSPASSAGENS *empp)
{
empp->iniciop=NULL;
empp->fimp=NULL;
}
int passagemvazio(struct CADASTROSPASSAGENS *empp)
{
if(empp->iniciop==NULL)
{
return 1;
}else
{
return 0;
}
}
//---------------------------------------------------------------------------------int

cadastrarPassagem(struct

CADASTROSPASSAGENS

*empp,

struct

Passagens

passagens)
{
struct Passagens *novopassagem;
novopassagem=(struct Passagens*) malloc(sizeof(struct Passagens));
if(novopassagem!=NULL)
{
novopassagem->numerovoo = passagens.numerovoo;
novopassagem->numeropassagem = passagens.numeropassagem;
strcpy(novopassagem->dataembarque, passagens.dataembarque);
strcpy(novopassagem->horaembarque, passagens.horaembarque);
strcpy(novopassagem->portaoembarque, passagens.portaoembarque);
novopassagem->prox=NULL;
16

if(passagemvazio(empp)>0)
{
empp->iniciop=novopassagem;
empp->fimp=novopassagem;
}
else
{
empp->fimp->prox=novopassagem;
empp->fimp=novopassagem;
}
}
printf("Passagem Cadastrada com sucesso\n");
system("pause");
return 0;
}
//---------------------------------------------------------------------------------void consultarPassagem(struct CADASTROSPASSAGENS *empp, int numpassagem)
{
struct Passagens *vp;
int verificador = 0;
vp=empp->iniciop;
if(empp->iniciop== NULL)
{
printf("N??o existe Passagem cadastrada.\n");
system("pause");
}else{
while(vp!=NULL)
{
if (vp->numeropassagem==numpassagem)
{
verificador = 1;
printf("--------------------------------------\n");
printf("Informacoes da Passagem numero %d\n",vp->numeropassagem);
17

printf("Data:%s\n", vp->dataembarque);
printf("Hora: %s\n",vp->horaembarque);
printf("Aeroporto de Saida: %s\n",vp->portaoembarque);
printf("--------------------------------------\n");
}
vp=vp->prox;
}
if (verificador == 0)
{
printf("Nao existe Passagem com este numero cadastrado, tente novamente\n");
}
system("pause");
system("cls");
}
}

18

Descrio do Programa Foi proposto no passo 3 da 2 Etapa, que fosse desenvolvido

um programa em linguagem C que trabalha-se com uma estrutura de dados denominada
Passagem. Esta estrutura, assim como a do programa anterior deveria ser implementada de
forma dinmica, e utilizaramos as funes cadastrarPassagem, e consultarPassagem, para
trabalhar com a estrutura.Basicamente, o que foi feito foi adaptar as funes e a estrutura do
programa 2.0 .

19

RELATRIO 03 _Filas e Pilhas

Pilhas
O funcionamento de uma pilha consiste numa estratgia chamada LIFO (last in, first
out ltimo a entrar, primeiro a sair). Alm disso, o nico elemento que se pode acessar na
pilha o elemento do topo da mesma, ou seja, o ltimo a ser empilhado. Pense numa pilha de
pratos. Quando se vai lav-los, voc no comea retirando o que est mais abaixo, e sim o que
est no topo da pilha. basicamente assim que esse tipo de estrutura funciona.
Filas
Basicamente o que diferencia a fila da pilha a ordem de sada dos elementos.
Enquanto na pilha o elemento retirado sempre o ltimo a entrar (o do topo da pilha), na fila
sempre retirado o primeiro elemento a entrar na estrutura. Podemos fazer uma analogia com
uma fila de banco por exemplo, onde a primeira pessoa a ser atendida a que chega primeiro.
medida que outras pessoas chegam na fila, devero permanecer na fila aguardando que
sejam atendidas, seguindo este critrio.
Passo02_Taxiamento
#include<stdio.h>
#include<stdlib.h>
using namespace std;
struct taxiamento{
int numero;
char modelo[20];
char empresa[20];
int saida;
struct taxiamento* prox;
};
typedef struct taxiamento TAXI;
TAXI* inicializar_Taxiamento(void) {
return NULL;
}
TAXI* cadastrar_Taxiamento(TAXI* t){
TAXI* novo = (TAXI*) malloc(sizeof(TAXI));
20

printf("Informe o numero do Voo: ");

scanf("%d",&novo->numero);
printf("Informe o modelo da aeronave: ");
scanf("%s",&novo->modelo);
printf("Informe a empresa: ");
scanf("%s",&novo->empresa);
printf("Informe o horario de saida: ");
scanf("%d",&novo->saida);
novo->prox = t;
return novo;
free(novo);
};
void imprimir_Taxiamento(TAXI* t){
TAXI* aux;
for (aux = t; aux != NULL; aux = aux->prox) {
printf("Numero do Voo......: %d \n",aux->numero);
printf("Modelo da Aeronave.: %s \n",aux->modelo);
printf("Empresa Aerea......: %s \n",aux->empresa);
printf("Horario de Saida...: %d \n",aux->saida);
system ("pause");
}
}
void autorizar_Taxiamento(TAXI* t) {
TAXI* aux = t ;
TAXI* ant = NULL;
while (aux->prox != NULL) {
ant = aux;
aux = aux->prox;
}
ant->prox = NULL;
t = ant;
printf("Taximento Autorizado! \n\n");
system ("pause");
21

free(aux);
}
int main (int argc, char *argv[]) {
TAXI* VoeBem;
VoeBem = inicializar_Taxiamento();
int opcao;
do {
system("CLS");
system("TITLE ETAPA 3 - Passo 2 ");
printf("\t\t\t Estrutura Taximento");
printf("\n\n\n");
printf("\t 1 - cadrastrar Taxiamento \n");
printf("\t 2 - Exibir Taxiamento \n");
printf("\t 3 - Autorizar Taxiamento \n");
printf("\t 0 - Sair ");
printf("\n\n");
printf("\t Digite a opcao: ");
scanf ("%d",&opcao);
switch(opcao){
case 1:
VoeBem = cadastrar_Taxiamento(VoeBem);
break;
case 2:
imprimir_Taxiamento(VoeBem);
break;
case 3:
autorizar_Taxiamento(VoeBem);
break;
case 0:
break;
default:
printf("\n Opcao incorreta, tente novamente!\n");
system ("pause");
22

};
} while (opcao != 0);
system ("pause");
return EXIT_SUCCESS;
}

Passo 03_Bagagem
#include<stdio.h>
#include<stdlib.h>
using namespace std;
struct bagagem{
int codigo;
int passagem;
int embarque;
int horaEmbarque;
char portao[20];
struct bagagem* prox;
};
typedef struct bagagem BAGAGEM;
BAGAGEM* inicializar_Bagagem (void) {
23

return NULL;
}
BAGAGEM* cadastrar_Bagagem(BAGAGEM* b) {
BAGAGEM* novo = (BAGAGEM*) malloc(sizeof(BAGAGEM));
printf("Informe o codigo da bagagem: ");
scanf("%d",&novo->codigo);
printf("Informe o numero da passagem: ");
scanf("%d",&novo->passagem);
printf("Informe a data do embarque: ");
scanf("%d",&novo->embarque);
printf("Informe o horario do embarque: ");
scanf("%d",&novo->horaEmbarque);
printf("Informe o numero do portao de embarque : ");
scanf("%s",&novo->portao);
system("cls");
novo->prox = b;
return novo;
}
void
imprimir_Bagagem(BAGAGEM* b) {
BAGAGEM* aux;
for (aux = b; aux != NULL; aux = aux->prox) {
printf("Voo.................: %d \n", aux->codigo);
printf("Passagem............: %d \n", aux->passagem);
printf("Embarque............: %d \n", aux->embarque);
printf("Hora do Embarque....: %d \n", aux->horaEmbarque);
printf("Portao de Embarque..: %s \n", aux->portao);
}
system ("pause");
};
void autorizar_Bagagem (BAGAGEM* b) {
BAGAGEM* aux = b ;
BAGAGEM* ant = NULL;
24

while (aux->prox != NULL) {

ant = aux;
aux = aux->prox;
}
ant->prox= NULL;
b = ant;
printf("Bagagem Autorizada! \n\n");
system ("pause");
free(aux);
};
BAGAGEM* recuperar_Bagagem (BAGAGEM* b) {
BAGAGEM* aux = b;
b = aux->prox;
printf("\n Bagagem recuperada! \n");
system("pause");
return b;
free(aux);
};
int main (int argc, char *argv[]) {
BAGAGEM* VoeBem;
VoeBem = inicializar_Bagagem();
int opcao;
do {
system("CLS");
system("TITLE ETAPA 3 - Passo 3 ");
printf("\t\t\t Estrutura Bagagem");
printf("\n\n\n");
printf("\t 1 - Cadrastrar Bagagem \n");
printf("\t 2 - Recuperar Bagagem \n");
printf("\t 3 - Autorizar Bagagem \n");
printf("\t 0 - Sair ");
printf("\n\n");
printf("\t Digite a opcao: ");
25

scanf ("%d",&opcao);
switch(opcao){
case 1:
VoeBem = cadastrar_Bagagem(VoeBem);
break;
case 2:
imprimir_Bagagem(VoeBem);
break;
case 3:
autorizar_Bagagem(VoeBem);
break;
case 0:
break;
default:
printf("\n Opcao incorreta, tente novamente!\n");
system ("pause");
}
} while (opcao != 0);
system ("pause");
return EXIT_SUCCESS;
}

26

Relatrio 04_Grafos.
Passos 01_02
Antes de tudo, vamos tentar entender o que um grafo. Um grafo uma estrutura
matemtica usada para representar as relaes entre as coisas. Essas "coisas" que se
relacionam entre si so chamados de ns do grafo. Cada relacionamento entre os ns
chamado de aresta. Normalmente, para facilitar sua visualizao e sua compreenso, grafos
so representados graficamente. No confunda as duas palavras! Grafos so entidades
matemticas, abstratas, que possuem ns (coisas) e arestas (relacionamento entre essas
coisas). Grficos so imagens. Grafos podem ser representados graficamente, mas o grafo
no a sua representao grfica - existem vrias outras maneiras de representar grafos que
no graficamente.Um grafo um tipo especial de dgrafo, tambm conhecido como grafonodirigido e grafo no-orientado. Um grafo um dgrafo simtrico. Os arcos de um grafo andam
aos pares: cada arco v-w acompanhado do arco w-v.
Dependendo da aplicao, arestas podem ou no ter direo, pode ser permitido ou no
arestas ligarem um vrtice a ele prprio e vrtices e/ou arestas podem ter um peso (numrico)
associado. Se as arestas tm uma direo associada (indicada por uma seta na representao
grfica)

temos

um grafo

direcionado, grafo

orientado ou dgrafo.

Convm tratar esse par de arcos com distino. Assim, diremos que um par de arcos antiparalelos uma aresta (= edge). As pontas dos dois arcos so as pontas da aresta.
As duas pontas de uma aresta so indistinguveis: no h ponta inicial nem ponta
final.Uma aresta com pontas v e w ser denotada, indiferentemente, por v-w ou w-v.
Diremos que uma aresta v-w liga os vrtices v e w. Diremos tambm que v-w incide em v e
em w. O nmero de arestas de um grafo a metade do seu nmero de arcos. Se E denota o
nmero de arestas e A denota o nmero de arcos ento A = 2E.
Algoritmo De Menor Caminho
O algoritmo de Dijkstra foi desenvolvido por Edsger Wybe Dijkstra em 1959. Este
algoritmo tem por funo encontrar o caminho mais curto entre duas arestas dentro de um
grafo. Para definio deste caminho mnimo necessrio que cada aresta possua um peso
positivo, ou seja, cada aresta deve possuir uma mtrica para que o algoritmo possa encontrar
um caminho onde a soma dos pesos das arestas seja o mais baixo entre todos os caminhos
possveis.
27

Durante sua execuo, o algoritmo mantm dois atributos d[v] e p[v] para cada vrtice
v. d[v] uma estimativa (ou limite) superior da distncia do vrtice fonte s at v. Alm disso,
se d[v] for finito, significa que o algoritmo encontrou at aquele momento um caminho de s a
v com peso d[v]. p[v] armazena o predecessor de v em um caminho de s a v com peso d[v].
utilizado para representar a rvore de caminhos mnimos que o algoritmo devolve .

Aps

ter inicializado o algoritmo realiza uma serie de comparaes que consiste em atualizar a
estimativa de distncia de um vrtice ao longo de uma aresta.
Matriz De Adjacncia
Uma matriz de adjacncia uma das formas de se representar um grafo.Dado um
grafo G com n vrtices,

podemos

represent-lo

em

uma matriz n x n A(G)=[aij]

(ou

simplesmente A). A definio precisa das entradas da matriz varia de acordo com as
propriedades do grafo que se deseja representar, porm de forma geral o valor aij guarda
informaes sobre como os vrtices vi e vj esto relacionados (isto , informaes sobre a
adjacncia de vi e vj).Para representar um grafo no direcionado, simples e sem pesos nas
arestas, basta que as entradas aij da matriz A contenham 1 se vi e vj so adjacentes e 0 caso
contrrio. Se as arestas do grafo tiverem pesos, aij pode conter, ao invs de 1 quando houver
uma aresta entre vi e vj, o peso dessa mesma aresta.
Caminhamento Em Amplitude
Representa um dos mais simples algoritmos de busca em grafos. usado como modelo
para alguns algoritmos importantes: Menor caminho. rvore de cobertura mnima.Similar
ao caminhamento por nveis em rvores.Idia: processa os vrtices por nveis, comeando por
queles vrtices mais prximos do vrtice inicial s e deixando os vrtices mais distantes para
pois.O algoritmo BFS pode ser resumido nos seguintes passos:Distinguir o vrtice inicial
s.Sistematicamente explorar as arestas do grafo para descobrir todos os vrtices alcanveis a
partir de s.Computar a distncia (menor nmero de arestas) de s para todos os vrtices
alcanveis.Produzir uma rvore de amplitude cuja raiz s e contm todos os vrtices
alcanveis.
Para todo vrtice v alcanvel a partir de s, o caminho na rvore de amplitude
corresponde ao menor caminho de s para v no grafo.
Caminhamento Em Profundidade
28

O caminhamento em profundidade realizado por algoritmos de busca, com o

objetivo de analisar todos os vrtices e arestas de um determinado grafo. Conforme destacam,
um algoritmo para ser considerado eficiente, deve realizar a visita em todos os vrtices e
arestas, em um espao de tempo proporcional a quantidade dos mesmos.
O algoritmo de caminhamento em profundidade analisa uma sequncia de Vrtices
adjacentes, a partir de um dado vrtice (v), e conclui o caminhamento somente quando todos
os vrtices alcanveis a partir de (v) so visitados.Para que sejam distintos os vrtices e
arestas j visitados, utilizam-se recursos adicionais durante o processo de caminhamento. A
associao de uma marca a um dado vrtice (v) j visitado, permite distingui-lo dos vrtices
ainda no visitados. Por conseguinte, surgem os

conceitos

de vrtice inicial,

vrtice marcado, aresta de incidncia ou descoberta e aresta de retorno.

O vrtice inicial aquele que selecionado como ponto inicial do caminhamento em
profundidade. J o vrtice marcado, consiste na seleo do vrtice v, a partir do qual se
iniciar a explorao de uma aresta (v,w) ainda no explorada. As arestas de descoberta so
arestas no exploradas, incidentes sobre um vrtice marcado, a partir da qual so descobertos
outros vrtices.
Passo_03
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void menu();
void montargrafo();
void caminhagrafo() ;
void selecao();
main()
{
int

I,J,N,N1,N2,

menor,T,R,NO_ATUAL,DIST_ATUAL,LUGAR_INICIAL,LUGAR_FINAL;
int A[10][10];
char cidade[10];
int vet_no_ant;
int vet_caminho;
29

int vet_peso;
int vet_resposta;
menu();
return 0;
system("pause");
}
void menu()
{
printf("\n Empresa VOEBEM \n");
printf(" ============================ \n\n");
printf(" ____________________________\n");
printf("| Escolha uma opcao abaixo |\n");
printf("|-------------------------- |\n");
printf("| 1 - Cadastrar Cidades |\n");
printf("| 2 - Melhor rota |\n");
printf("| 0 - Sair |\n");
printf("|__________________________ |\n");
selecao();
}
void selecao(){
int opcao;
printf("\nDigite uma das opcoes: ");
scanf("%i", &opcao);
switch (opcao){
case 1:
montargrafo();
menu();
break;
case 2:
caminhagrafo();
menu();
break;

30

case 0:
system("pause");
exit(0);
break;
default:
printf("\n\nOpcao nao encontrada.\nTente Novamente\n\n");
system("pause");
system("cls");
menu();
break;
}
}
FUNO MONTAR GRAFO (CADASTRO DE CIDADES)
void montargrafo(){
int num;
do{
printf("\n\n*****CADASTRO DE CIDADES*****\n");
for(I=0;I

31

CONCLUSO
Conclumos atravs das etapas deste trabalho como funciona e como podem ser
aplicados, diversos assuntos tratados em sala de estrutura de dados. Entendendo como suas
aplicaes podem ajudar na compilao de um programa,ex: um sistema de cadastro de
avies. Os conceitos bsicos da linguagem de programao C a qual tem se tornado cada dia
mais popular, devido sua versatilidade e ao seu poder. Uma das grandes vantagens do C
que ele possui tanto caractersticas de "alto nvel" quanto de "baixo nvel". Apesar de ser bom,
no pr-requisito do curso um conhecimento anterior de linguagens de programao.
importante uma familiaridade com computadores.

32

BIBLIOGRAFIA
http://www.cprogressivo.net/2013/10/Estrutura-de-dados-dinamica-em-C-Listas-Filas-PilhasArvores.html
http://www.di.ufpb.br/liliane/aulas/estruturas.html
http://programacaodescomplicada.wordpress.com/indice/estrutura-de-dados/
http://www.google.com.br/url?
sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=&ved=0CB8QFjAA&url=http
%3A%2F%2Fwww.inf.pucrs.br%2F~pinho%2FLaproI%2FVeores
%2FVetores.htm&ei=KM5WVPa5D7T_sASBvIGYAQ&usg=AFQjCNEgNRVXadSmphWdq
XPoN05nreQ0w&sig2=gUfC6rX22wF9G5pjZ T7LA&bvm=bv.78677474,d.cWc
https://docs.google.com/file/d/0B_uLQd5hdqlWcnBnQVk0YVpTUXFzUmMyc1NWaVpvQ
Q/edit?pli=1
https://docs.google.com/file/d/0B_uLQd5hdqlWTVFzdzZRYTZSSDJRRm9hLVg1RjRxZw/e
dit
https://docs.google.com/file/d/0B_uLQd5hdqlWQXdYT19jQUJUd2Vob1BYQ3dWZEkydw/
edit
https://docs.google.com/file/d/0B_uLQd5hdqlWUVV6N0FxbzdRZm1KT0d2Y282bU1Zdw/d
it
https://docs.google.com/file/d/0B_uLQd5hdqlWdU9tQi1yS1pTQXUzNEQ1d3BsbkZBUQ/ed
it

33