Programação C
Trabalho Escolar: Programação C. Pesquise 860.000+ trabalhos acadêmicosPor: • 27/9/2013 • 10.877 Palavras (44 Páginas) • 187 Visualizações
/*********** Simulação de Aeroportos usando Estruturas de Dados ***************/
/** Objetivo: Trabalhar com filas e listas ligadas *****/
/** Nome do arquivo : simulacaoDoAeroporto.c ***********/
/** Nome dos alunos : Augusto, Bruna, Diego, Erickson, Filipe ***********/
/** Email : edelgado@ime.usp.br ***********/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#define COMPANHIAS 5
typedef struct aeroporto {
int idAER;
char *iniciaisAER;
char *nome;
float distanciaKmAER;
int distanciaUtAER;
char companhiasAER[COMPANHIAS];
struct aeroporto *proximo;
} Aeroporto;
typedef struct companhia {
int idCOM;
char *iniciaisCOM;
char *nomeCOM;
struct companhia *proximo;
} Companhia;
typedef struct aviao {
int idAVI;
char iniAerAVI[3];
int duracaoAVI;
char iniComAVI[2];
int tipoAVI;
int emergenciaAVI;
int tempoEsperaAVI;
struct aviao *proximo;
} Aviao;
typedef struct estadistica {
int nAvioesP;
int nAvioesD;
int nAvioesEsperaP;
int nAvioesEsperaD;
int tEsperaP;
int tEsperaD;
float tMedioEsperaP;
float tMedioEsperaD;
int qCombEP;
int qCombDP;
float qMediaCEP;
float qMediaCDP;
int nAvioesEmergP;
int nAvioesEmergD;
int nAvioesDesv;
} Estadistica;
typedef struct {
Aviao *v;
struct aviao *ini;
struct aviao *fim;
int tam;
} t_fila;
Aeroporto *principal = NULL;
Companhia *p_companhia = NULL;
t_fila fila;
Estadistica estad_global,estad_local;
int pista1=0,pista2=0,pista3=0;
void cria_fila() {
fila.tam = 0;
fila.ini = fila.fim = NULL;
if ((fila.v = malloc(sizeof(*(fila.v))))==NULL) {
printf("Memória insuficiente!\n");
getchar();
exit(0);
}
}
void ini_estadistica_local() {
estad_local.nAvioesP=0;
estad_local.nAvioesD=0;
estad_local.nAvioesEsperaP=0;
estad_local.nAvioesEsperaD=0;
estad_local.tEsperaP=0;
estad_local.tEsperaD=0;
estad_local.tMedioEsperaP=0.0;
estad_local.tMedioEsperaD=0.0;
estad_local.qCombEP=0;
estad_local.qCombDP=0;
estad_local.qMediaCEP=0.0;
estad_local.qMediaCDP=0.0;
estad_local.nAvioesEmergP=0;
estad_local.nAvioesEmergD=0;
estad_local.nAvioesDesv=0;
}
void ini_estadistica_global() {
estad_global.nAvioesP=0;
estad_global.nAvioesD=0;
estad_global.nAvioesEsperaP=0;
estad_global.nAvioesEsperaD=0;
estad_global.nAvioesEmergP=0;
estad_global.nAvioesEmergD=0;
estad_global.tEsperaP=0;
estad_global.tEsperaD=0;
estad_global.tMedioEsperaP=0.0;
estad_global.tMedioEsperaD=0.0;
estad_global.qCombEP=0;
estad_global.qCombDP=0;
estad_global.qMediaCEP=0.0;
estad_global.qMediaCDP=0.0;
estad_global.nAvioesDesv=0;
}
void exibe_estadistica_local()
{
int totalAvioesP=estad_local.nAvioesP+estad_local.nAvioesEmergP+estad_local.nAvioesEsperaP;
int totalAvioesD=estad_local.nAvioesD+estad_local.nAvioesEmergD+estad_local.nAvioesEsperaD;
if(totalAvioesP!=0)
{
estad_local.tMedioEsperaP=estad_local.tEsperaP/(float)totalAvioesP;
estad_local.qMediaCEP=estad_local.qCombEP/(float)totalAvioesP;
estad_local.qMediaCDP=estad_local.qCombDP/(float)totalAvioesP;
}
if(totalAvioesD!=0)
{
estad_local.tMedioEsperaD=(float)estad_local.tEsperaD/(float)totalAvioesD;
}
fprintf(stdout,"Nro. avioes pousaram [%d]\n",estad_local.nAvioesP);
fprintf(stdout,"Nro. avioes decolaram [%d]\n",estad_local.nAvioesD);
fprintf(stdout,"Nro. avioes esperam pousar [%d]\n",estad_local.nAvioesEsperaP);
fprintf(stdout,"Nro. avioes esperam decolar [%d]\n",estad_local.nAvioesEsperaD);
fprintf(stdout,"Nro. avioes pousaram emergencia [%d]\n",estad_local.nAvioesEmergP);
fprintf(stdout,"Nro. avioes decolaram emergencia [%d]\n",estad_local.nAvioesEmergD);
fprintf(stdout,"Tempo espera de pousos [%d]\n",estad_local.tEsperaP);
fprintf(stdout,"Tempo espera de decolagens [%d]\n",estad_local.tEsperaD);
fprintf(stdout,"Tempo medio de espera pousar [%4.2f]\n",estad_local.tMedioEsperaP);
fprintf(stdout,"Tempo medio de espera decolar [%4.2f]\n",estad_local.tMedioEsperaD);
fprintf(stdout,"Quant. combust. avioes esperando pousar [%d]\n",estad_local.qCombEP);
fprintf(stdout,"Quant. combust. avioes pousaram [%d]\n",estad_local.qCombDP);
fprintf(stdout,"Quant. media combust. avioes esperando pousar [%4.2f]\n",estad_local.qMediaCEP);
fprintf(stdout,"Quant. media combust. avioes pousaram [%4.2f]\n",estad_local.qMediaCDP);
fprintf(stdout,"Nro. avioes desviados [%d]\n",estad_local.nAvioesDesv);
}
void exibe_estadistica_global()
{
int totalAvioesP=estad_global.nAvioesP+estad_global.nAvioesEmergP+estad_global.nAvioesEsperaP;
int totalAvioesD=estad_global.nAvioesD+estad_global.nAvioesEmergD+estad_global.nAvioesEsperaD;
if(totalAvioesP!=0)
{
estad_global.tMedioEsperaP=estad_global.tEsperaP/(float)totalAvioesP;
estad_global.qMediaCEP=estad_global.qCombEP/(float)totalAvioesP;
estad_global.qMediaCDP=estad_global.qCombDP/(float)totalAvioesP;
}
if(totalAvioesD!=0)
{
estad_global.tMedioEsperaD=estad_global.tEsperaD/(float)totalAvioesD;
}
fprintf(stdout,"Nro. avioes pousaram [%d]\n",estad_global.nAvioesP);
fprintf(stdout,"Nro. avioes decolaram [%d]\n",estad_global.nAvioesD);
fprintf(stdout,"Nro. avioes esperam pousar [%d]\n",estad_global.nAvioesEsperaP);
fprintf(stdout,"Nro. avioes esperam decolar [%d]\n",estad_global.nAvioesEsperaD);
fprintf(stdout,"Nro. avioes pousaram emergencia [%d]\n",estad_global.nAvioesEmergP);
fprintf(stdout,"Nro. avioes decolaram emergencia [%d]\n",estad_global.nAvioesEmergD);
fprintf(stdout,"Tempo espera de pousos [%d]\n",estad_global.tEsperaP);
fprintf(stdout,"Tempo espera de decolagens [%d]\n",estad_global.tEsperaD);
fprintf(stdout,"Tempo medio de espera pousar [%4.2f]\n",estad_global.tMedioEsperaP);
fprintf(stdout,"Tempo medio de espera decolar [%4.2f]\n",estad_global.tMedioEsperaD);
fprintf(stdout,"Quant. combust. avioes esperando pousar [%d]\n",estad_global.qCombEP);
fprintf(stdout,"Quant. combust. avioes pousaram [%d]\n",estad_global.qCombDP);
fprintf(stdout,"Quant. media combust. avioes esperando pousar [%4.2f]\n",estad_global.qMediaCEP);
fprintf(stdout,"Quant. media combust. avioes pousaram [%4.2f]\n",estad_global.qMediaCDP);
fprintf(stdout,"Nro. avioes desviados [%d]\n",estad_global.nAvioesDesv);
}
void insere_aviao(int idAVI, char iniAerAVI[3], int duracaoAVI, char iniComAVI[2], int tipoAVI, int emergenciaAVI, int tempoEsperaAVI){
Aviao *novo;
novo = (Aviao *)malloc(sizeof(Aviao));
novo->idAVI=idAVI;
strncpy(novo->iniAerAVI, iniAerAVI, strlen(iniAerAVI)+1);
strncpy(novo->iniComAVI, iniComAVI, strlen(iniComAVI)+1);
novo->duracaoAVI=duracaoAVI;
novo->tipoAVI=tipoAVI;
novo->emergenciaAVI=emergenciaAVI;
novo->tempoEsperaAVI=tempoEsperaAVI;
novo->proximo = NULL;
if ((fila.v = realloc(NULL,fila.tam*sizeof(*(fila.v))))==NULL) {
printf("Memória insuficiente!\n");
getchar();
exit(0);
}
if(fila.fim==NULL || fila.ini==NULL)
{
fila.ini=novo;
fila.fim=novo;
}
else
{
fila.fim->proximo=novo;
fila.fim=fila.fim->proximo;
}
fila.tam++;
}
Aviao *remove_aviao (Aviao *avioes, int chave) {
Aviao *p;
Aviao *r;
if (fila_vazia()) {
printf("Fila vazia!! Underflow!!\n");
getchar();
exit(0);
}
if(avioes==NULL && chave==0)
{
r=fila.ini;
p=r;
fila.ini=fila.ini->proximo;
free(r);
fila.tam--;
}
else
{
if(avioes->idAVI == chave)
{
r=avioes;
p=r;
avioes=avioes->proximo;
free(r);
fila.tam--;
}
else
{
for (; avioes != NULL; avioes = avioes->proximo) {
if (avioes->proximo->idAVI==chave) {
break;
}
}
if (avioes->proximo!=NULL)
{
r=avioes->proximo;
p=r;
avioes->proximo=avioes->proximo->proximo;
free(r);
fila.tam--;
}
}
}
return p;
}
void exibe_aviao(Aviao *r)
{
fprintf(stdout,"[%s %s]",r->tipoAVI==0?"Decolar":"Pousar ",r->emergenciaAVI==0?"Normal":"Emerg");
fprintf(stdout,"[%s-%d]",r->iniComAVI,r->idAVI);
if(r->tipoAVI==0)
fprintf(stdout,"[G-%s]",r->iniAerAVI);
else
fprintf(stdout,"[%s-G]",r->iniAerAVI);
fprintf(stdout,"[Duracao %d]",r->duracaoAVI);
fprintf(stdout,"[Espera %d]\n",r->tempoEsperaAVI);
}
int estado_pistas_desvios(Aviao *r)
{
int estado=0;
if(pista1==0)
{
pista1=1;
estado=1;
}
else
{
if(pista2==0)
{
pista2=1;
estado=2;
}
else
{
if(pista3==0)
{
pista3=1;
estado=3;
}
else
{
if(r->tipoAVI==0)// Decolar
{
estado=5;// Esperar
}
else // Pousar
{
if(r->emergenciaAVI==1)
{
estado=4;// Desviar obligatoriamente
}
else
{
estado=5;//Esperar
}
}
}
}
}
return estado;
}
void msn_estado_pistas_desvios(int estado, Aviao *r)
{
switch(estado)
{
case 1:
fprintf(stdout,"[Pista 1]");
if(r->tipoAVI==0)// Decolar
{
if(r->emergenciaAVI==1)
{
estad_local.nAvioesEmergD++;
}
else
{
estad_local.nAvioesD++;
}
}
else// Pousar
{
if(r->emergenciaAVI==1)
{
estad_local.nAvioesEmergP++;
}
else
{
estad_local.nAvioesP++;
}
estad_local.qCombDP+=r->duracaoAVI;
}
break;
case 2:
fprintf(stdout,"[Pista 2]");
if(r->tipoAVI==0)// Decolar
{
if(r->emergenciaAVI==1)
{
estad_local.nAvioesEmergD++;
}
else
{
estad_local.nAvioesD++;
}
}
else// Pousar
{
if(r->emergenciaAVI==1)
{
estad_local.nAvioesEmergP++;
}
else
{
estad_local.nAvioesP++;
}
estad_local.qCombDP+=r->duracaoAVI;
}
break;
case 3:
fprintf(stdout,"[Pista 3]");
if(r->tipoAVI==0)// Decolar
{
if(r->emergenciaAVI==1)
{
estad_local.nAvioesEmergD++;
}
else
{
estad_local.nAvioesD++;
}
}
else// Pousar
{
if(r->emergenciaAVI==1)
{
estad_local.nAvioesEmergP++;
}
else
{
estad_local.nAvioesP++;
}
estad_local.qCombDP+=r->duracaoAVI;
}
break;
case 4:
fprintf(stdout,"[Desviar]");
estad_local.nAvioesDesv++;
break;
case 5:
fprintf(stdout,"[Esperar]");
if(r->tipoAVI==0)// Decolar
{
estad_local.tEsperaD+=r->tempoEsperaAVI;
estad_local.nAvioesEsperaD++;
}
else// Pousar
{
estad_local.tEsperaP+=r->tempoEsperaAVI;
estad_local.qCombEP+=r->duracaoAVI;
estad_local.nAvioesEsperaP++;
}
break;
default:
break;
}
fprintf(stdout,"[%s %s]",r->tipoAVI==0?"Decolar":"Pousar ",r->emergenciaAVI==0?"Normal":"Emerg");
fprintf(stdout,"[%s-%d]",r->iniComAVI,r->idAVI);
if(r->tipoAVI==0)
fprintf(stdout,"[G-%s]",r->iniAerAVI);
else
fprintf(stdout,"[%s-G]",r->iniAerAVI);
fprintf(stdout,"[Duracao %d]",r->duracaoAVI);
fprintf(stdout,"[Espera %d]\n",r->tempoEsperaAVI);
}
void atende_emergencia (Aviao *avioes, int chave) {
Aviao *p=NULL;
Aviao *r=NULL;
Aviao *q=NULL;
int estado;//1:pista1, 2:pista2, 3:pista3, 4:desvio(pousar), 5:esperar(decoular), 6:caida(pousar)
// if (fila_vazia()) {
// printf("Fila vazia!! Underflow!!!\n");
// getchar();
// exit(0);
// }
p=avioes;
while(p != NULL)
{
if(p->emergenciaAVI == chave)
{
r=p;
estado=estado_pistas_desvios(r);
msn_estado_pistas_desvios(estado,r);
if(p==fila.ini)
{
p=p->proximo;
fila.ini=p;
}
else
{
p=p->proximo;
}
if(r==fila.fim)
{
fila.fim=NULL;
}
free(r);
fila.tam--;
}
else
{
if (p->proximo != NULL && p->proximo->emergenciaAVI == chave)
{
r=p->proximo;
if(r==fila.fim)
{
fila.fim=p;
p->proximo=p->proximo->proximo;
}
else
{
p->proximo=p->proximo->proximo;
}
estado=estado_pistas_desvios(r);
msn_estado_pistas_desvios(estado,r);
//printf("\nEmergencia!! Atendidos!!\n");
//exibe_aviao(r);
free(r);
fila.tam--;
}
else
p = p->proximo;
}
}
}
void atende_normal (Aviao *avioes) {
Aviao *p=NULL;
Aviao *r=NULL;
Aviao *q=NULL;
int estado;
// if (fila_vazia()) {
// printf("Fila vazia!! Underflow!!!\n");
// getchar();
// exit(0);
// }
p=avioes;
while(p != NULL)//en cada t al final
{
if(pista1==0 || pista2==0 || pista3==0)
{
if(p->tipoAVI==0)// Decoular
{
r=p;
estado=estado_pistas_desvios(r);
msn_estado_pistas_desvios(estado,r);
if(p==fila.ini)
{
p=p->proximo;
fila.ini=p;
}
else
{
p=p->proximo;
}
if(r==fila.fim)
{
fila.fim=NULL;
}
free(r);
fila.tam--;
}
else // Pousar
{
if(pista1==0 || pista2==0)
{
r=p;
estado=estado_pistas_desvios(r);
msn_estado_pistas_desvios(estado,r);
if(p==fila.ini)
{
p=p->proximo;
fila.ini=p;
}
else
{
p=p->proximo;
}
free(r);
fila.tam--;
}
else // Esperar
{
estado=5;
msn_estado_pistas_desvios(estado,p);
p->tempoEsperaAVI++;
p->duracaoAVI--;
if(p->duracaoAVI<=1) // Se todas as pistas estao ocupadas, a estrategia para evitar que avioes caiam e desviar suas rotas ao aeroporto mais perto.
{
p->emergenciaAVI=1;
}
p=p->proximo;
}
}
}
else // Esperar ou desviar
{
estado=estado_pistas_desvios(p);
msn_estado_pistas_desvios(estado,p);
p->tempoEsperaAVI++;
if(p->tipoAVI==0)// Decolar
{
if(p->tempoEsperaAVI > 0.10*p->duracaoAVI)
{
p->emergenciaAVI=1;
}
}
else // Pousar
{
p->duracaoAVI--;
// Se todas as pistas estao ocupadas, a estrategia para evitar
// que avioes caiam e desviar suas rotas ao aeroporto mais perto.
if(p->duracaoAVI<=1)
{
p->emergenciaAVI=1;
}
}
p=p->proximo;
}
}
}
Aviao *busca_aviao(Aviao *avioes, int chave) {
for (; avioes != NULL; avioes = avioes->proximo) {
if (avioes->idAVI==chave) {
break;
}
}
return avioes;
}
int fila_vazia() {
return fila.tam==0;
}
/* FILA: Verifica se a fila esta cheia. */
//int fila_cheia() {
//return fila.ini == (fila.fim + 1) % fila.tam;
//}
Aviao *remove_fila () {
Aviao *p;
Aviao *r;
if (fila_vazia()) {
printf("Fila vazia!! Underflow!!\n");
getchar();
exit(0);
}
r=fila.ini;
p=r;
fila.ini=r->proximo;
free(r);
fila.tam--;
return p;
}
Aviao *primeiro_fila()
{
return fila.ini;
}
void exibe_fila()
{
int i;
Aviao *r=NULL;
r=fila.ini;
for(; r !=NULL; r = r->proximo)
{
fprintf(stdout,"[%s %s]",r->tipoAVI==0?"Decolar":"Pousar ",r->emergenciaAVI==0?"Normal":"Emerg");
fprintf(stdout,"[%s-%d]",r->iniComAVI,r->idAVI);
if(r->tipoAVI==0)
fprintf(stdout,"[G-%s]",r->iniAerAVI);
else
fprintf(stdout,"[%s-G]",r->iniAerAVI);
fprintf(stdout,"[Duracao %d]",r->duracaoAVI);
fprintf(stdout,"[Espera %d]\n",r->tempoEsperaAVI);
}
}
Aeroporto *inicia_aeroportos(int idAER, char *iniciaisAER, char *nomeAER, float distanciaKmAER, int distanciaUtAER, char companhiasAER[]) {
Aeroporto *novo;
novo = (Aeroporto *)malloc(sizeof(Aeroporto));
novo->idAER = idAER;
novo->iniciaisAER = (char *)malloc(strlen(iniciaisAER)+1);
novo->nomeAER = (char *)malloc(strlen(nomeAER)+1);
strncpy(novo->iniciaisAER, iniciaisAER, strlen(iniciaisAER)+1);
strncpy(novo->nomeAER, nomeAER, strlen(nomeAER)+1);
strncpy(novo->companhiasAER, companhiasAER, strlen(companhiasAER)+1);
novo->distanciaKmAER = distanciaKmAER;
novo->distanciaUtAER = distanciaUtAER;
novo->proximo = NULL;
return novo;
}
Aeroporto *insere_aeroportos(Aeroporto *aeroportos, int idAER, char *iniciaisAER, char *nomeAER, float distanciaKmAER, int distanciaUtAER, char companhiasAER[]) {
Aeroporto *novo;
novo = (Aeroporto *)malloc(sizeof(Aeroporto));
novo->idAER = idAER;
novo->iniciaisAER = (char *)malloc(strlen(iniciaisAER)+1);
novo->nomeAER = (char *)malloc(strlen(nomeAER)+1);
strncpy(novo->iniciaisAER, iniciaisAER, strlen(iniciaisAER)+1);
strncpy(novo->nomeAER, nomeAER, strlen(nomeAER)+1);
strncpy(novo->companhiasAER, companhiasAER, strlen(companhiasAER)+1);
novo->distanciaKmAER = distanciaKmAER;
novo->distanciaUtAER = distanciaUtAER;
novo->proximo = aeroportos;
return novo;
}
void exibe_aeroportos(Aeroporto *aeroportos) {
fprintf(stdout, "------------------------\n");
for (; aeroportos != NULL; aeroportos = aeroportos->proximo) {
fprintf(stdout, "[Id:%i]", aeroportos->idAER);
fprintf(stdout, "[Iniciais:%s]", aeroportos->iniciaisAER);
fprintf(stdout, "[Distancia Ut:%i]", aeroportos->distanciaUtAER);
fprintf(stdout, "[Companhias:%s]", aeroportos->companhiasAER);
fprintf(stdout, "\n");
}
getchar();
}
void busca_aeroportos(Aeroporto *aeroportos, int chave) {
int achou = 0;
fprintf(stdout, "Resuldados da busca:\n\n");
for (; aeroportos != NULL; aeroportos = aeroportos->proximo) {
if (aeroportos->idAER==chave) {
fprintf(stdout, "[Id:%i]", aeroportos->idAER);
fprintf(stdout, "[Iniciais:%s]", aeroportos->iniciaisAER);
fprintf(stdout, "[Distancia Ut:%i]", aeroportos->distanciaUtAER);
fprintf(stdout, "[Companhias:%s]", aeroportos->companhiasAER);
fprintf(stdout, "\n");
achou++;
}
}
if (achou == 0)
fprintf(stdout, "Nenhum resultado encontrado.\n");
else
fprintf(stdout, "Foram encontrados %d registros.\n", achou);
getchar();
}
Aeroporto *busca_aeroporto(Aeroporto *aeroportos, int chave) {
for (; aeroportos != NULL; aeroportos = aeroportos->proximo) {
if (aeroportos->idAER==chave) {
break;
}
}
return aeroportos;
}
Aeroporto *deleta_aeroportos(Aeroporto *aeroportos) {
Aeroporto *novo;
novo = aeroportos->proximo;
free(aeroportos->iniciaisAER);
free(aeroportos->nomeAER);
free(aeroportos->companhiasAER);
free(aeroportos);
fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.\n");
getchar();
return novo;
}
int checa_vazio(Aeroporto *aeroportos) {
if (aeroportos == NULL) {
//fprintf(stdout, "Lista vazia!\n");
//getchar();
return 1;
} else
return 0;
}
int conta_aeroportos(Aeroporto *aeroportos, int uT)
{
int achou = 0;
if (!checa_vazio(aeroportos))
{
for (; aeroportos != NULL; aeroportos = aeroportos->proximo)
{
if (aeroportos->distanciaUtAER<=uT)
{
achou++;
}
}
}
return achou;
}
int id_aeroporto(Aeroporto *aeroportos, int uT){
int achou = 0;
if (!checa_vazio(aeroportos))
{
for (; aeroportos != NULL; aeroportos = aeroportos->proximo)
{
if (aeroportos->distanciaUtAER<=uT)
{
achou=aeroportos->idAER;
break;
}
}
}
return achou;
}
void insere(int idAER, char *iniciaisAER, char *nomeAER, float distanciaKmAER, int distanciaUtAER, char *companhiasAER)
{
if (principal == NULL)
principal = inicia_aeroportos(idAER, iniciaisAER, nomeAER, distanciaKmAER, distanciaUtAER, companhiasAER);
else
principal = insere_aeroportos(principal, idAER, iniciaisAER, nomeAER, distanciaKmAER, distanciaUtAER, companhiasAER);
}
void exibe(void) {
if (!checa_vazio(principal))
exibe_aeroportos(principal);
}
void busca(int chave) {
if (!checa_vazio(principal)) {
busca_aeroportos(principal, chave);
}
}
void deleta(void) {
if (!checa_vazio(principal))
principal = deleta_aeroportos(principal);
}
Companhia *inicia_companhias(int idCOM, char *iniciaisCOM, char *nomeCOM){
Companhia *novo;
novo = (Companhia *)malloc(sizeof(Companhia));
novo->idCOM = idCOM;
novo->iniciaisCOM = (char *)malloc(strlen(iniciaisCOM)+1);
novo->nomeCOM = (char *)malloc(strlen(nomeCOM)+1);
strncpy(novo->iniciaisCOM, iniciaisCOM, strlen(iniciaisCOM)+1);
strncpy(novo->nomeCOM, nomeCOM, strlen(nomeCOM)+1);
novo->proximo = NULL;
return novo;
}
Companhia *insere_companhias(Companhia *companhias, int idCOM, char *iniciaisCOM, char *nomeCOM){
Companhia *novo;
novo = (Companhia *)malloc(sizeof(Companhia));
novo->idCOM = idCOM;
novo->iniciaisCOM = (char *)malloc(strlen(iniciaisCOM)+1);
novo->nomeCOM = (char *)malloc(strlen(nomeCOM)+1);
strncpy(novo->iniciaisCOM, iniciaisCOM, strlen(iniciaisCOM)+1);
strncpy(novo->nomeCOM, nomeCOM, strlen(nomeCOM)+1);
novo->proximo = companhias;
return novo;
}
void exibe_companhias(Companhia *companhias){
fprintf(stdout, "------------------------\n");
for (; companhias != NULL; companhias = companhias->proximo) {
fprintf(stdout, "[Id:%i]", companhias->idCOM);
fprintf(stdout, "[Iniciais:%s]", companhias->iniciaisCOM);
fprintf(stdout, "[Nome:%s]", companhias->nomeCOM);
fprintf(stdout, "\n");
}
getchar();
}
void busca_companhias(Companhia *companhias, int chave){
int achou = 0;
fprintf(stdout, "Resuldados da busca:\n\n");
for (; companhias != NULL; companhias = companhias->proximo) {
if (companhias->idCOM==chave) {
fprintf(stdout, "[Id:%i]", companhias->idCOM);
fprintf(stdout, "[Iniciais:%s]", companhias->iniciaisCOM);
fprintf(stdout, "[Nome:%s]", companhias->nomeCOM);
fprintf(stdout, "\n");
achou++;//mudar a exit
}
}
if (achou == 0)
fprintf(stdout, "Nenhum resultado encontrado.\n");
else
fprintf(stdout, "Foram encontrados %d companhias.\n", achou);
getchar();
}
Companhia *busca_companhia(Companhia *companhias, int chave) {
for (; companhias != NULL; companhias = companhias->proximo) {
if (companhias->idCOM==chave) {
break;
}
}
return companhias;
}
Companhia *deleta_companhias(Companhia *companhias){
Companhia *novo;
novo = companhias->proximo;
free(companhias->iniciaisCOM);
free(companhias->nomeCOM);
free(companhias);
fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.\n");
getchar();
return novo;
}
int checa_vazio_companhias(Companhia *companhias){
if (companhias == NULL) {
fprintf(stdout, "Lista vazia!\n");
getchar();
return 1;
} else
return 0;
}
void insere_com(int idCOM, char *iniciaisCOM, char *nomeCOM)
{
if (p_companhia == NULL)
p_companhia = inicia_companhias(idCOM, iniciaisCOM, nomeCOM);
else
p_companhia = insere_companhias(p_companhia, idCOM, iniciaisCOM, nomeCOM);
}
void exibe_com(void)
{
if (!checa_vazio_companhias(p_companhia))
exibe_companhias(p_companhia);
}
void busca_com(int chave)
{
if (!checa_vazio_companhias(p_companhia)) {
busca_companhias(p_companhia, chave);
}
}
void deleta_com(void)
{
if (!checa_vazio_companhias(p_companhia))
p_companhia = deleta_companhias(p_companhia);
}
int RandomInteger(int low, int high)
{
int k;
double d;
d = (double) rand () / ((double) RAND_MAX + 1);
k = d * (high - low + 1);
return low + k;
}
void Randomize (int semente)
{
srand (semente);
}
void ini_tabela_aeroportos(void)
{
insere(1,"GRU","Aeroporto Internacional de São Paulo-Guarulhos (GRU)",0.0,0,"12345");
insere(2,"SBM","Aeroporto Campo de Marte (SBM)",9.67,1,"1235");
insere(3,"CGH","Aeroporto de Congonhas (CGH)",27.7,4,"135");
insere(4,"SDT","Aeroporto de Atibaia (SDT)",37.16,5,"135");
insere(5,"VCP","Aeroporto Internacional de Viracopos (VCP)",51.86,7,"14");
insere(6,"DAS","Aeroporto de Americana (DAS)",55.57,8,"23");
insere(7,"ITA","Aeroporto de Itanhaém (ITA)",55.4,8,"15");
insere(8,"QDV","Aeroporto de Jundiaí (QDV)",58.64,8,"25");
insere(9,"SJK","Aeroporto de São José dos Campos (SJK)",66.9,9,"24");
insere(10,"SOD","Aeroporto de Sorocaba (SOD)",64.84,9,"2");
insere(11,"PIR","Aeroporto de Piracicaba (PIR)",87.82,12,"135");
insere(12,"QCP","Aeroporto de Botucatu (QCP)",131.94,18,"24");
insere(13,"QSC","Aeroporto de São Carlos (QSC)",140.15,19,"15");
insere(14,"AQA","Aeroporto de Araraquara (AQA)",154.02,21,"3");
insere(15,"SD1","Aeroporto de Arandu (SD1)",162.43,23,"24");
insere(16,"SD2","Aeroporto de Avaré (SD2)",162.90,23,"24");
insere(17,"BAU","Aeroporto de Bauru (BAU)",180.90,25,"24");
insere(18,"RAO","Aeroporto de Ribeirão Preto (RAO)",178.41,25,"2");
insere(19,"JTC","Aeroporto de Bauru-Arealva (JTC)",187.15,26,"15");
insere(20,"FRC","Aeroporto de Franca (FRC)",202.85,28,"24");
insere(21,"OUR","Aeroporto de Ourinhos (OUR)",221.96,31,"135");
insere(22,"BAT","Aeroporto de Barretos (BAT)",236.55,33,"3");
insere(23,"LIN","Aeroporto de Lins (LIN)",240.86,33,"35");
insere(24,"MII","Aeroporto de Marília (MII)",236.13,33,"4");
insere(25,"AIF","Aeroporto de Assis (AIF)",260.13,36,"24");
insere(26,"PEN","Aeroporto de Penápolis (PEN)",266.92,37,"4");
insere(27,"TUP","Aeroporto de Tupã (TUP)",279.15,39,"135");
insere(28,"ARU","Aeroporto de Araçatuba (ARU)",295.69,41,"15");
insere(29,"DRA","Aeroporto de Dracena (DRA)",355.33,49,"3");
insere(30,"SD3","Aeroporto de Andradina (SD3)",360.39,50,"14");
}
void ini_tabela_companhias(void)
{
insere_com(1,"LA","LAN PERÚ");
insere_com(2,"IB","IBERIA");
insere_com(3,"GO","GOL");
insere_com(4,"AF","AIR FRANCE");
insere_com(5,"TA","TAM");
}
int main(void) {
int i,j;
int escolha;
int K,C,V,T,S;
int k,c,v;
int nAviao=1;
int tipo;
int rDuracao;
int numAero;
int idRandAero;
int duracao;
int emergencia;
int idRandComp;
int idComp;
char temp;
int atendeuL=0;
int atendeuG=0;
int validacao=1;
Aviao *av1=NULL,*av2=NULL;
Aeroporto *aeroportos=NULL;
Companhia *companhias=NULL;
do
{
fprintf(stdout, "\n\nIngrese K: ");scanf("%d", &K);
fprintf(stdout, "Ingrese C: ");scanf("%d", &C);
fprintf(stdout, "Ingrese V: ");scanf("%d", &V);
fprintf(stdout, "Ingrese T: ");scanf("%d", &T);
fprintf(stdout, "Ingrese semente: ");scanf("%d", &S);
if(K<=0 || C<=0 || V<=0 || T<=0 || S<=0)
{
validacao=0;
fprintf(stdout, "\nValidacao: Algum dado incorreto");
}
else
{
validacao=1;
}
}while(validacao==0);
Randomize(S);
cria_fila();
ini_estadistica_global();
ini_tabela_aeroportos();
ini_tabela_companhias();
FILE *stream ;
if((stream = freopen("Saida.txt", "w", stdout)) == NULL)
exit(-1);
printf("Simulação do Aeroporto\n");
//stream = freopen("CON", "w", stdout);
//printf("-----------------------\n");
fprintf(stdout,"K=%d C=%d V=%d T=%d \n",K,C,V,T);
fprintf(stdout, "***********************************************\n");
for(i=0; i<T; i++)
{
pista1=0,pista2=0,pista3=0;
ini_estadistica_local();
atendeuL=0;
fprintf(stdout,"\n\n[t=%i]",i);
k=RandomInteger(0, K);
fprintf(stdout,"[k=%i]\n",k);
for(j=0; j<k; j++)
{
duracao=0;
tipo=RandomInteger(0,1)<0.5?0:1;
if(tipo==0)
{
rDuracao=RandomInteger(1, V);
numAero=id_aeroporto(principal,rDuracao);
idRandAero=RandomInteger(2, numAero);
if(!checa_vazio(principal))
{
aeroportos=busca_aeroporto(principal,idRandAero);
duracao=aeroportos->distanciaUtAER;
idRandComp=RandomInteger(1,strlen(aeroportos->companhiasAER));
temp=aeroportos->companhiasAER[idRandComp-1];
idComp=atoi(&temp);
companhias=busca_companhia(p_companhia,idComp);
}
}
else
{
idRandAero=RandomInteger(2, 30);
if(!checa_vazio(principal))
{
aeroportos=busca_aeroporto(principal,idRandAero);
rDuracao=RandomInteger(1,C);
duracao=rDuracao;
idRandComp=RandomInteger(1,strlen(aeroportos->companhiasAER));
temp=aeroportos->companhiasAER[idRandComp-1];
idComp=atoi(&temp);
companhias=busca_companhia(p_companhia,idComp);
}
}
emergencia=RandomInteger(0,100)<15?1:0;
insere_aviao(nAviao,aeroportos->iniciaisAER,duracao,companhias->iniciaisCOM,tipo,emergencia,0);
nAviao++;
}
if(primeiro_fila()!=NULL)
{
fprintf(stdout, "\nFila de Avioes para Pousar e Decolar\n");
exibe_fila();
fprintf(stdout, "\nAvioes atendidos com Emergencia\n");
atende_emergencia (fila.ini,1);
fprintf(stdout, "\nAvioes atendidos Normal\n");
atende_normal (fila.ini);
fprintf(stdout, "\nEstadisticas da iteracao [%d]\n",i);
exibe_estadistica_local();
estad_global.nAvioesP+=estad_local.nAvioesP;
estad_global.nAvioesD+=estad_local.nAvioesD;
estad_global.nAvioesEsperaP+=estad_local.nAvioesEsperaP;
estad_global.nAvioesEsperaD+=estad_local.nAvioesEsperaD;
estad_global.nAvioesEmergP+=estad_local.nAvioesEmergP;
estad_global.nAvioesEmergD+=estad_local.nAvioesEmergD;
estad_global.tEsperaP+=estad_local.tEsperaP;
estad_global.tEsperaD+=estad_local.tEsperaD;
estad_global.qCombEP+=estad_local.qCombEP;
estad_global.qCombDP+=estad_local.qCombDP;
estad_global.nAvioesDesv+=estad_local.nAvioesDesv;
}
fprintf(stdout, "***********************************************\n");
}
fprintf(stdout, "\nEstadistica Global\n",i);
exibe_estadistica_global();
fprintf(stdout, "\nFila de Avioes nao atendidos.\n");
exibe_fila();
free(av1);
free(av2);
free(aeroportos);
free(companhias);
return 0;
}
...