int main(int argc, char **argv)
{
no *n;
lista *l;
lista *l2;
int i;
l = criaLista();
l2 = criaLista();
for(i = 1 ; i < 5 ; i++){
n = criaNo(i);
insereFim(l,n);
}
for(i = 1 ; i < 5 ; i++){
n = criaNo(i);
insereIni(l2,n);
}
printf("\n ***inserindo no fim e imprimindo*** \n");
imprimeLista(l);
printf("\n ***inserindo no inicio e imprimindo*** \n");
imprimeLista(l2);
liberaLista(l);/* libernado as listas*/
liberaLista(l2); /* libernado as listas*/
return 0;
}
void POT(pilha *P, No **raiz)
{
No *Aux ;
pai_a = (No*) malloc(sizeof(No));
pai_b = (No*) malloc(sizeof(No));
pai_c = (No*) malloc(sizeof(No));
pai_a = pop(P);
pai_b = pop(P);
pai_c = pop(P);
if(pai_c==NULL)
{
criaNo('$', &Aux);
Aux->esq = (No*)((int) (pow ((int)OperaSinais(pai_a->dir),(int)OperaSinais(pai_b->dir))));
*raiz = Aux;
}
else // Acredito que essa condicioanl Nunca sera usada....
{
criaNo('$', &Aux);
pai_c->esq = Aux;
pai_c->esq->esq = (No*)((int) (pow ((int)OperaSinais(pai_a->dir),(int)OperaSinais(pai_b->dir))));
DecodificaOperacao(pai_c->esq, P);
}
}
void BL(pilha *P, No **raiz)
{
pai_a = (No*) malloc(sizeof(No));
pai_b = (No*) malloc(sizeof(No));
pai_c = (No*) malloc(sizeof(No));
pai_d = (No*) malloc(sizeof(No));
pai_resto = (No*) malloc(sizeof(No));
No *Aux1 ;
No *Aux2 ;
No *Aux3 ;
criaNo('@', &Aux1);
criaNo('@', &Aux2);
criaNo('@', &Aux3);
if(tamPilha > 4)
{
pai_a = pop(P);
pai_b = pop(P);
pai_c = pop(P);
pai_d = pop(P);
pai_resto = pop(P);
Aux3->esq = pai_c->dir;
Aux3->dir = pai_d->dir;
Aux2->esq = pai_a->dir;
Aux2->dir = pai_b->dir;
Aux1->esq = Aux2;
Aux1->dir = Aux3;
pai_resto->esq = Aux1;
DecodificaOperacao(pai_resto, P);
}
else if(tamPilha == 4)
{
pai_a = pop(P);
pai_b = pop(P);
pai_c = pop(P);
pai_d = pop(P);
Aux3->esq = pai_c->dir;
Aux3->dir = pai_d->dir;
Aux2->esq = pai_a->dir;
Aux2->dir = pai_b->dir;
Aux1->esq = Aux2;
Aux1->dir = Aux3;
*raiz =Aux1;
DecodificaOperacao(*raiz, P);
}
else
{
Fim = 1;
}
}
/* Insere de forma desordenada, de acordo com os dados passados na entrada padrão */
void insere(int n, Sequencia* comeco){
Sequencia* aux, *ant;
if(comeco == NULL)
criaNo(n, NULL);
else{
aux = comeco;
while(aux != NULL){
ant = aux;
aux = aux->prox;
}
ant->prox = criaNo(n, aux);
}
}
int main(int argc, char **argv)
{
int numeroJobs;
numeroJobs = atoi(argv[1]);
algoritmo tipo = verificaTipo(argv[2]);
tPermuta p = lerPermuta(numeroJobs);
no n = criaNo(p);
listaGen l = criaListaGen();
pushBack(l, n);
tPermuta result;
if(tipo == BS)
{
result = beamSearch(l, 5); //TODO: testar esse numero aqui (beamWidth)
}
else if(tipo == BB)
{
result = branchBound(l);
}
imprimePermuta(result);
liberaPermuta(result);
liberaListaGen(l, liberaPermuta);
return 0;
}
int main()
{
struct Arvore *t = criaArvore();
int num;
char c[5];
gets(c);
while(scanf("%d", &num) != EOF)
inserir(t, criaNo(&num));
if(strcmp(c, "POS") == 0)
posOrdem(t->raiz);
else if(strcmp(c, "PRE") == 0)
preOrdem(t->raiz);
else
inOrdem(t->raiz);
printf("%d", altura(t->raiz));
printf(" %d", rotacao);
}
void inserirPorID (Lista * lst, QuadroPagina* item, int posicao)
{
No * no = lst->prim;
No * novoNo = criaNo(item);
if (posicao > lst->tam)
{
printf("Indice de lista não existente. \n");
exit(0);
}
if (posicao == 0)
{
inserirPrimeiro(lst, item);
return;
}
else
{
if(lst->tam == posicao)
{
inserirUltimo(lst, item);
return;
}
while (posicao>0)
{
no = no->prox;
posicao--;
}
inserirAntes(lst, no, novoNo);
lst->tam++;
}
}
/*
* Árvore binária cheia representada
* pelo seguinte modelo:
*
* 1
* / \
* 2 3
* / \ / \
* 4 5 6 7
*/
int main(void){
Arvore* arvore = criaNo(1,
criaNo(2,
criaNo(4,
criaNoVazio(),
criaNoVazio()
),
criaNo(5,
criaNoVazio(),
criaNoVazio()
)
),
criaNo(3,
criaNo(6,
criaNoVazio(),
criaNoVazio()
),
criaNo(7,
criaNoVazio(),
criaNoVazio()
)
)
);
arvoreImprime(arvore);
arvorePertence(3, arvore);
arvorePertence(8, arvore);
arvoreNivel(5, arvore);
liberaNo(arvore);
return 0;
}
int main(){
int i;
lista l;
no n;
criaLista(&l);
for(i = 0; i < 10; i++){
criaNo(&n,i);
insereFim(&l,n);
}
criaNo(&n,5);
insereNCopias(&l,n,2,4);
printf("\n**INSERE NCOPIAS\n");
imprimeLista(&l);
liberaLista(&l);
return 0;
}
int main(int argc, char **argv)
{
no *n;
lista *l;
lista *l2;
lista *l3;
int i,k;
l = criaLista();
l2 = criaLista();
l3 = criaLista();
for(i = 1 ; i < 5 ; i++){
n = criaNo(i);
insereFim(l,n);
}
for(i = 2 ; i < 6 ; i++){
n = criaNo(i);
insereFim(l2,n);
}
printf("\n **lista ** \n");
imprimeLista(l);
printf("\n **lista 2** \n");
imprimeLista(l2);
printf("\n **uniao ** \n");
uniao(l,l2,l3);
imprimeLista(l3);
liberaLista(l3);
l3 = criaLista();
printf("\n **intersecao ** \n");
intersecao(l,l2,l3);
imprimeLista(l3);
k = pertence(l,l2);
printf("\n \n 0 - NAO \n 1 - SIM \n");
printf("pertence: %d \n",k);
liberaLista(l);
liberaLista(l2);
liberaLista(l3);
return 0;
}
/* Funcao que cria uma lista com n nos, n eh passado na entrada */
No* criaLista(int n_nos, No* p){
int contador = 0;
int preenche = 0;
while(contador < n_nos){
p = criaNo(preenche, p);
preenche++;
contador++;
}
return p;
}
void uniao(lista *l1, lista *l2, lista *l3){
no *aux;
no *aux2;
int i,j;
aux = l1->ini;
i = j = 0;
while(i < (l1 -> tam)){
aux2 = criaNo(aux->conteudo);
insereFim(l3,aux2);
aux = aux -> prox;
i++;
}
aux = l2->ini;
while(j < (l2 -> tam)){
aux2 = criaNo(aux -> conteudo);
insereFim(l3,aux2);
aux = aux -> prox;
j++;
}
}
void trocaPos(lista *l, int pos1, int pos2){
int i;
no *aux;
no *aux2;
if(pos1 < l->tam && pos2 < l->tam){
for( i = 0 , aux = l -> ini; i < pos1; aux = aux -> prox , i++);
aux2 = criaNo(aux ->conteudo);
removePos(l,pos1);
printf("%d",aux2 -> conteudo);
inserePos(l,aux2,pos2);
}
}
void ordenaListaDescrescente(lista *l1, lista *l2){
int cont, cont2, verifica;
no *aux;
no *aux2;
no *pega;
aux = l1 -> ini;
pega = criaNo(aux -> conteudo);
insereFim(l2,pega);
aux = aux -> prox;
cont = 1;
while(cont < l1 -> tam ){
aux2 = l2 -> ini;
cont2 = 0;
verifica = 0;
while(cont2 < l2 -> tam ){
if(aux->conteudo > aux2 -> conteudo){
if(cont2 == 0){
pega = criaNo(aux -> conteudo);
insereIni(l2,pega);
verifica++;
cont2 = l2 -> tam;
}else{
pega = criaNo(aux -> conteudo);
insereEsq(l2,pega,cont2);
verifica++;
cont2 = l2 -> tam;
}
}
cont2++;
aux2 = aux2 -> prox;
}
if(verifica == 0){
pega = criaNo(aux -> conteudo);
insereFim(l2,pega);
}
cont++;
aux = aux -> prox;
}
}
/* Funcao que insere um contato de maneira ordenada */
void insereOrdenado(int tel_lido, char nome_lido[], Agenda **lista){
Agenda* aux, *ant;
aux = NULL;
if((*lista) == NULL){
*lista = criaNo(tel_lido, nome_lido, aux);
return;
}
else{
aux = *lista;
if(strcmp(nome_lido,aux->nome) < 0){
*lista = criaNo(tel_lido, nome_lido, *lista);
}
else{
while(aux != NULL && strcmp(nome_lido,(*aux).nome) > 0){
ant = aux;
aux = aux->next;
}
ant->next = criaNo(tel_lido, nome_lido, aux);
}
}
}
void Special(int key, int x, int y){
switch(key){
case GLUT_KEY_F1 :
gravaGrafo();
break;
case GLUT_KEY_F2 :
leGrafo();
glutPostRedisplay();
break;
case GLUT_KEY_F6 :
numNos=numArcos=0;
addNo(criaNo( 0, 10,0)); // 0
addNo(criaNo( 0, 5,0)); // 1
addNo(criaNo(-5, 5,0)); // 2
addNo(criaNo( 5, 5,0)); // 3
addNo(criaNo(-5, 0,0)); // 4
addNo(criaNo( 5, 0,0)); // 5
addNo(criaNo(-5, -5,0)); // 6
addArco(criaArco(0,1,1,1)); // 0 - 1
addArco(criaArco(1,2,1,1)); // 1 - 2
addArco(criaArco(1,3,1,1)); // 1 - 3
addArco(criaArco(2,4,1,1)); // 2 - 4
addArco(criaArco(3,5,1,1)); // 3 - 5
addArco(criaArco(4,5,1,1)); // 4 - 5
addArco(criaArco(4,6,1,1)); // 4 - 6
glutPostRedisplay();
break;
case GLUT_KEY_UP:
estado.camera.eyeVer[0] += 1 * cos(estado.camera.dir_long)*cos(estado.camera.dir_lat);
estado.camera.eyeVer[1] += 1 * sin(estado.camera.dir_long)*cos(estado.camera.dir_lat);
estado.camera.eyeVer[2] += 1 * sin(estado.camera.dir_lat);
glutPostRedisplay();
break;
case GLUT_KEY_DOWN:
estado.camera.eyeVer[0] -= 1 * cos(estado.camera.dir_long)*cos(estado.camera.dir_lat);
estado.camera.eyeVer[1] -= 1 * sin(estado.camera.dir_long)*cos(estado.camera.dir_lat);
estado.camera.eyeVer[2] -= 1 * sin(estado.camera.dir_lat);
glutPostRedisplay();
break;
/*case GLUT_KEY_LEFT :
estado.camera.eyeVer[1] -= 1 * cos(estado.camera.dir_long)*cos(estado.camera.dir_lat);
estado.camera.eyeVer[0] -= 1 * sin(estado.camera.dir_long)*cos(estado.camera.dir_lat);
glutPostRedisplay();
break;
case GLUT_KEY_RIGHT:
estado.camera.eyeVer[1] += 1 * cos(estado.camera.dir_long)*cos(estado.camera.dir_lat);
estado.camera.eyeVer[0] += 1 * sin(estado.camera.dir_long)*cos(estado.camera.dir_lat);
glutPostRedisplay();
*/
break;
}
}
/* fazer uma cópia da lista*/
void copiaLista(lista *l1, lista *l2){
no *aux;
no *pega;
int i;
liberaLista(l1);
l1 = criaLista();
aux = l2 -> ini;
i = 0;
while(i < (l2 -> tam)){
pega = criaNo(aux -> conteudo);
insereFim(l1,pega);
aux = aux -> prox;
i++;
}
}
int main(){
int i;
lista l;
no n;
criaLista(&l);
for(i = 0; i < 10; i++){
criaNo(&n,i);
insereFim(&l,n); /* inserindo no Fim*/
}
printf("\n *** removendo a 2 pos***\n");
removePos(&l,2);
imprimeLista(&l);
liberaLista(&l);
return 0;
}
/* Faça a inversão através da inversão dos campos de ligação, e NÃO dos
campos de informação.*/
void inverteLista(lista *l, lista *l2){
no *aux;
no *pega;
aux = l->ini;
pega = aux;
while(aux != NULL){
pega = criaNo(aux -> conteudo);
if (l2 -> tam != 0)
{
pega -> prox = l2 -> ini;
}
else
l2 -> fim = pega;
l2 -> ini = pega;
l2 -> tam++;
aux = aux->prox;
}
}
void inserirUltimo (Lista * lst, QuadroPagina* item)
{
No * NovoNo = criaNo(item);
No * cabeca = lst->prim;
No * cauda = lst->ult;
if (cabeca == NULL)
lst->prim = NovoNo;
else
{
No * ult = cauda;
if (cauda == NULL)
ult = cabeca;
ult->prox = NovoNo;
NovoNo->ant = ult;
lst->ult = NovoNo;
}
lst->tam++;
}
int main(int argc, char **argv)
{
int i;
lista *l;
no *n;
l = criaLista();
for(i = 0; i < 5; i++){
n = criaNo(i);
insereFim(l,n);
}
printf("\n**lista normal**\n");
imprimeLista(l);
//~ trocaPos(l,2,3);
trocaPos(l,2,3);
printf("\n**lista trocaPos**\n");
imprimeLista(l);
//~ liberaLista(l);
return 0;
}
void inserirPrimeiro (Lista * lst, QuadroPagina* item)
{
No * NovoNo = criaNo(item);
No * cabeca = lst->prim;
No * cauda = lst->ult;
if (cabeca == NULL)
lst->prim = NovoNo;
else
{
if (cauda == NULL)
cauda = cabeca;
NovoNo->prox = cabeca;
cabeca->ant = NovoNo;
lst->prim = NovoNo;
lst->ult = cauda;
}
lst->tam++;
}
tree* insereArv(tree *arv, char letra)
{
if(arv == NULL)
{
arv = criaNo(letra, arv, arv);
}
else
{
if(letra > arv->dado)
{
//direita
arv->dir = insereArv(arv->dir, letra);
}
else
{
//esquerda
arv->esq = insereArv(arv->esq, letra);
}
}
return arv;
}
void intersecao(lista *l1, lista *l2, lista *l3){
int cont, cont2;
no *aux;
no *aux2;
no *pega;
cont = 0;
aux = l1 -> ini;
while(cont < l1 -> tam ){
aux2 = l2 -> ini;
cont2 = 0;
while(cont2 < l2 -> tam ){
if(aux->conteudo == aux2 -> conteudo){
pega = criaNo(aux -> conteudo);
insereFim(l3,pega);
}
cont2++;
aux2 = aux2 -> prox;
}
cont++;
aux = aux -> prox;
}
}
Grafo lerGrafo(){
Grafo grafo(1000);
ifstream infilestream;
string line;
//N
int tipo;
string id;
//R
int no1;
int no2;
int i=0;
infilestream.open("grafo2.txt");
while (infilestream) {
infilestream >> line;
if(line=="N") {
infilestream >> tipo;
infilestream >> id;
criaNo(tipo,id, &grafo);
}
if(line=="R") {
infilestream >> no1;
infilestream >> no2;
criaRelacaoBin(no1, no2, &grafo);
}
void intersecao2(lista *l1, lista *l2, lista *l4){
int cont, cont2;
no *aux;
no *aux2;
no *pega;
cont = 0;
aux = l2 -> ini;
while(cont < l2 -> tam ){
aux2 = l1 -> ini;
cont2 = 0;
while(cont2 < l1 -> tam ){
pega = buscaPos(l4,aux2);
if(pega == NULL){
pega = criaNo(aux2 -> conteudo);
insereFim(l4,pega);
}
cont2++;
aux2 = aux2 -> prox;
}
cont++;
aux = aux -> prox;
}
}
int main()
{
int i;
char strEntrada[200000];
No *Raiz;
pilha Pilha[10000];
OP = (No*) malloc(sizeof(No));
FILE *arq = fopen("string.in", "r");
fscanf(arq,"%s",strEntrada);
criaNo('@', &Raiz);
Raiz = criaGrafo(strEntrada, Raiz);
DecodificaOperacao(Raiz, Pilha);
//for(i = 0; i<1; i++)
while(Fim == 0 && Raiz->c != ':' && Raiz->c != '$')
{
OP = pop(Pilha);
switch (OP->c)
{
case 'S':
if(Verifica(3,Pilha, &Raiz))
{
S(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_S++;
#endif
}
break;
case 'K':
K(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_K++;
#endif
break;
case 'B':
if(Verifica(3,Pilha, &Raiz))
{
B(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_B++;
#endif
}
break;
case 'b':
if(Verifica(3,Pilha, &Raiz))
{
BL(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_BL++;
#endif
}
break;
case 'P':
if(Verifica(3,Pilha, &Raiz))
{
CL(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_CL++;
#endif
}
break;
case 'I':
I(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_I++;
#endif
break;
case 'W':
if(Verifica(3,Pilha, &Raiz))
{
SL(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_SL++;
#endif
}
break;
case 'C':
if(Verifica(3,Pilha, &Raiz))
{
C(Pilha, &Raiz);
#ifdef CONT_FLAG
cont_C++;
#endif
}
break;
case 'H': //Hd
Hd(Pilha, &Raiz);
break;
case 'T': //Tl
Tl(Pilha, &Raiz);
break;
case '*':
MULT(Pilha, &Raiz);
break;
case '/':
DIV(Pilha, &Raiz);
break;
case '-':
SUB(Pilha, &Raiz);
break;
case '+':
ADD(Pilha, &Raiz);
break;
case '^':
POT(Pilha, &Raiz);
break;
default:
Fim = 1;
break;
}
}
printf("Saida: ");
printaGrafo(Raiz);
printf("\n");
printf("\nChamadas ao GC:%d\n", garbage);
#ifdef CONT_FLAG
printf("S: %d\n",cont_S);
printf("K: %d\n",cont_K);
printf("I: %d\n",cont_I);
printf("C: %d\n",cont_C);
printf("B: %d\n",cont_B);
printf("S': %d\n",cont_SL);
printf("C': %d\n",cont_CL);
printf("B': %d\n",cont_BL);
#endif
return 0;
}
int main()
{
FILE *entrada;
entrada=fopen("Arquivo_das_viagens.txt","a+");
Amigo *amigos;
//*amigos, SALVA A LISTA DE TODOS AMIGOS
Deslocamento *deslocamentos;
//*deslocamentos, SALVA A LISTA DE TODOS DESLOCAMENTOS
Data *dias;
//*dias, LISTA COM DIAS DAS VIAGENS
amigos=criaAmigo();
deslocamentos=criaDeslocamento();
dias=criaNo();
int opcao=0,verificador=0, verificador2=0, info1=0,info2=0,info3=0,k=0;
/*opcao, COLETA AS OPCOES DO USUARIO
verificadores, IRAO COLETAR CERTAS INFORMACOES PARA SEREM VERIFICADAS
*/
char informa1[50], informa2[50], informa3[50];
//informa1,2,3, SALVARAO DADOS FORNECIDOS PELO USUARIO
do
{
printf("1-INSERIR AMIGO\n");
printf("2-INSERIR DESLOCAMENTO\n");
printf("3-INSERIR VIAGEM\n");
printf("4-CANCELAR VIAGEM\n");
printf("5-DESISTENCIA DE AMIGO\n");
printf("6-PESQUISAR VIAGENS POR INTEVALOS DE DIAS\n");
printf("7-VIAGENS DE UM AMIGO\n");
printf("8-SAIR\n");
printf("OPCAO: ");
scanf("%d",&opcao);
system("cls");
//APOS A COLETA DA OPCAO, INICIA O QUE DEVE SER FEITO
switch(opcao)
{
//CASE 1 E PARA INSERÇÃO DE PESSOAS
case 1:
printf("NOME: ");
setbuf(stdin,NULL);
strupr(gets(informa1));
/*
O verificador e a variavel que contera o valor da funçao checaAmigos.
Essa funçao tem como objetivo checar toda a lista de amigos, e verificar se o novo amigo a ser inserido
ja existe. Caso exista alguem com mesmo nome, o verificador passara a valer 1. Caso contrario continuara com 0.
*/
verificador=checaAmigos(amigos,informa1);
if(verificador==0)
{
printf("TELEFONE: ");
setbuf(stdin,NULL);
gets(informa2);
printf("EMAIL: ");
setbuf(stdin,NULL);
gets(informa3);
}
else
{
printf("NOME JA CADASTRADO!\n\n");
break;
}
//DADOS SAO ENVIADOS PARA FUNCAO
amigos=insereAmigo(amigos,informa1,informa2,informa3);
system("cls");
break;
//CASE 2 E PARA A INSERÇÃO DE DESLOCAMENTOS
case 2:
//Pergunta para verificar se é uma viagem para o exterior, tais casos afetarao a inserção da informação
printf("VIAGEM PARA EXTERIOR?\n");
printf("1-SIM\n2-NAO\n");
printf("OPCAO: ");
scanf("%d",&verificador2);
system("cls");
//CASO SEJA UMA VIAGEM PARA O EXTERIOR
if(verificador2==1)
{
printf("NOME CIDADE: ");
setbuf(stdin,NULL);
strupr(gets(informa1));
/*
O verificador e a variavel que contera o valor da funçao checaViagem.
Essa funçao tem como objetivo checar toda a lista de cidades, e verificar se a nova cidade a ser inserida
ja existe. Caso exista alguma com mesmo nome, o verificador passara a valer 1. Caso contrario continuara com 0.
*/
verificador=checaViagem(deslocamentos,informa1);
if(verificador==0)
{
printf("PAIS: ");
setbuf(stdin,NULL);
strupr(gets(informa2));
//POR SER VIAGEM AO EXTERIOR, NÃO É NECESSARIO O NOME DO ESTADO, QUE SERA SUBSTITUIDO POR -
strcpy(informa3,"-");
//ENVIO DE DADOS PARA INSERÇÃO
deslocamentos=insereDeslocamento(deslocamentos,informa1,informa2,informa3);
system("cls");
}
else
{
printf("CIDADE JA CADASTRADA!\n\n");
break;
}
}
//CASO NÃO SEJA UMA VIAGEM PARA EXTERIOR
else
{
printf("NOME CIDADE: ");
setbuf(stdin,NULL);
strupr(gets(informa1));
/*
O verificador e a variavel que contera o valor da funçao checaViagem.
Essa funçao tem como objetivo checar toda a lista de cidades, e verificar se a nova cidade a ser inserida
ja existe. Caso exista alguma com mesmo nome, o verificador passara a valer 1. Caso contrario continuara com 0.
*/
verificador=checaViagem(deslocamentos,informa1);
if(verificador==0)
{
printf("ESTADO: ");
setbuf(stdin,NULL);
strupr(gets(informa3));
strcpy(informa2,"BRASIL");
//ENVIA DADOS PARA SEREM INSERIDOS
deslocamentos=insereDeslocamento(deslocamentos,informa1,informa2,informa3);
system("cls");
}
else
{
printf("CIDADE JA CADASTRADA!\n\n");
break;
}
}
break;
//CASE 3 E PARA O CADASTRAMENTO DE VIAGENS
case 3:
printf("DIA(dd/mm/aaaa): ");
scanf("%d/%d/%d",&info1,&info2,&info3);
/*
O verificador e a variavel que contera o valor da funçao checaData.
Essa funçao tem como objetivo checar toda a lista de datas, e verificar se a nova data a ser inserida
ja existe. Caso exista alguma no mesmo dia, o verificador passara a valer 1. Caso contrario continuara com 0.
*/
verificador=checaData(dias,info1,info2,info3);
if(verificador==0){
dias=insereData(dias,info1,info2,info3,amigos,deslocamentos);
if(k==0){
do{
k++;
printf("INSERIR MAIS ALGUEM?\n");
printf("1-SIM\n2-NAO\n");
printf("OPCAO: ");
scanf("%d",&verificador2);
system("cls");
if(verificador2==1)
dias=insere_mais_um(dias,amigos);
}while(verificador2!=2);
}
}
if(verificador==1){
dias=insere_na_mesma_data(dias,info1,info2,info3,amigos,deslocamentos);
}
break;
case 4:
imprimeAmigos(amigos);
printf("\n\n\n");
imprimeDeslocamento(deslocamentos);
printf("\n\n\n");
break;
case 5:
imprimeViagem(dias);
break;
}
}while(opcao!=8);
return 0;
}