Olá, estou com um problema: tenho que ler um arquivo de .csv que contem simulações de jogos entre dois times e/ou consultas ao ranking.Foi especificado que o numero de consultas é muito maior que o numero de simulações de jogos. Para não ficar muito custoso pensei em sempre inserir os times após cada simulação já de maneira ordenada, e se o time já tiver feito algum outro jogo, eu removo e insiro novamente ordenado. /**************************** Estruturas ****************************/
typedef int TipoChave;
typedef struct TipoTime {
char *nome;
int classificacao;
int pontos;
}TipoTime;
typedef struct TipoItem{
TipoChave Chave;
TipoTime Time;
}TipoItem;
typedef struct TipoCelula *TipoApontador;
typedef struct TipoCelula{
TipoItem Item;
TipoApontador Prox;
}TipoCelula;
typedef struct TipoLista{
TipoApontador Primeiro, Ultimo;
}TipoLista;/**************************** Funcoes ****************************/
void FLVazia (TipoLista *Lista);
int Vazia(TipoLista Lista);
void Insere (TipoItem x, TipoLista *Lista);
void Retira (TipoApontador p, TipoLista *Lista, TipoItem *Item);
void Imprime (TipoLista Lista);
void ImprimeNoArquivoDeSaida (TipoLista Lista);
int pesquisarTime(TipoLista *L , char *nome, TipoCelula *Celula);
void inserirOrdenado(TipoLista Lista , TipoItem *Time);
void atualizaVitoria(TipoLista Lista, TipoItem *Item, TipoApontador p);
void atualizaEmpate(TipoLista Lista, TipoItem *Item, TipoApontador p);/*Função que faz uma lista vazia*/
void FLVazia (TipoLista *Lista){
Lista -> Primeiro = (TipoApontador) malloc (sizeof(TipoCelula));
Lista -> Ultimo = Lista -> Primeiro;
Lista -> Primeiro -> Prox = NULL;
}
int Vazia(TipoLista Lista){
return (Lista.Primeiro == Lista.Ultimo);
}
/*Insere na lista*/
void Insere (TipoItem x, TipoLista *Lista){
Lista -> Ultimo -> Prox = (TipoApontador) malloc (sizeof (TipoCelula));
Lista -> Ultimo = Lista -> Ultimo -> Prox;
Lista -> Ultimo -> Item = x;
Lista -> Ultimo -> Prox = NULL;
}
/*Remove da lista*/
void Retira (TipoApontador p, TipoLista *Lista, TipoItem *Item){
TipoApontador q;
if ( (Vazia(*Lista)) || (p == NULL) || (p -> Prox == NULL) ){
printf ("\nErro: lista vazia ou posicao nao existe!!\n");
return;
}
q = p -> Prox;
*Item = q -> Item;
p -> Prox = q -> Prox;
if (p -> Prox == NULL){
Lista -> Ultimo = p;
}
free (q);
}
/*Imprime a lista*/
void Imprime (TipoLista Lista){
TipoApontador Aux;
Aux = Lista.Primeiro -> Prox;
while (Aux != NULL){
printf ("%d \n" , Aux -> Item.Chave);
Aux = Aux -> Prox;
}
}
/*void ImprimeNoArquivoDeSaida (TipoLista Lista){
TipoApontador Aux;
Aux = Lista.Primeiro -> Prox;
while (Aux != NULL){
fprintf (ArqSaida,"%d, \n" , Aux -> Item.Chave);
Aux = Aux -> Prox;
}
}*/
//pesquisa se já existem o time na lista.
int pesquisarTime(tlista *L,char *nome, TipoCelula *Celula){
TipoCelula *p;
TipoTime *Time;
while (p !=NULL){
Time = L->nome;
if (strcmp(nome,Time->nome)==0){
return 1;
}
}
return 0;
}
/*Esta função faz a inserção na lista de maneira ordenada*/
void inserirOrdenado(TipoLista Lista **p, *Time)
{
lista *atual, *novo, *anterior;
int num;
novo = (lista *) malloc(sizeof(lista));
atual = *p;
anterior = NULL;
novo->valor = Time;
if(atual == NULL){
novo->prox = NULL;
*p = novo;
} else{
while(atual != NULL && atual->valor < num){
anterior = atual;
atual = atual->prox;
}
novo->prox = atual;
if(anterior == NULL){
*p = novo;
} else{
anterior->prox = novo;
}
}
}
/*A função recebe o time vitorioso, copia para um time temporário.
chama a função Retira, para remover o item da lista
soma os 3 pontos da vitória e insere novamente de maneira ordenada*/
void atualizaVitoria(TipoLista Lista, TipoTime Time, TipoApontador p){
TipoItem ItemTemp;
//Copia o time para um TipoTime temporário.
ItemTemp.Time.nome = Item.Time.nome;
ItemTemp.Time.classificacao = Item.Time.classificacao;
ItemTemp.Time.pontos = Item.Time.pontos+3;//Ponteiro ou conteudo ?
Retira ( p, *Lista, *Item);
inserirOrdenado( Lista **p, *ItemTemp);
}
/*A função recebe os times que empataram(um por vez), copia para um time temporário.
chama a função Retira, para remover o item da lista
soma o 1 ponto da vitória e insere novamente de maneira ordenada*/
void atualizaEmpate(TipoLista Lista, TipoItem *Item, TipoApontador p){
TipoItem ItemTemp;
ItemTemp.Time.nome = Item.Time.nome;
ItemTemp.Time.classificacao = Item.Time.classificacao;
ItemTemp.Time.pontos = Item.Time.pontos+3;//Ponteiro ou conteudo ?
Retira ( p, *Lista, *Item);
inserirOrdenado( Lista **p, *ItemTemp);
}int main(){
/************************** VARIAVEIS *****************************/
char buffer[100];
int i = 0;
int flag = 1;
TipoLista Campeonato;
TipoItem ItemAux;
char *Acao;
char *TipoDaAcao;
char *NomeDoTime1;
char *NomeDoTime2;
/************************ LEITURA ARQUIVOS *******************************/
FILE *ArqEntrada; // leitura dos comandos
FILE *ArqSaida; // resultado dos comandos
FILE *ArqRanking; // arquivo do ranking ordenado
ArqEntrada = fopen("entrada.csv","r");
ArqSaida = fopen("saida.csv", "w");
ArqRanking = fopen("ranking.csv","r");
if (ArqEntrada == NULL) {
printf ("\nERRO: Arquivo de entrada incorreto!");
}
if (ArqSaida == NULL){
printf("\nERRO: Arquivo de saida incorreto!");
}
if (ArqRanking == NULL){
printf("\nERRO: Ranking nao encontrado. Sera gerado um novo.");
ArqRanking = fopen("ranking.csv","w");
flag = 0;
}
/************************ CARREGANDO SIMULAÇÕES ANTERIORES *******************************/
if (flag==1){
fgets (buffer, 100, ArqRanking);
while (!feof(ArqRanking)){
printf ("\n");
ItemAux.Time.nome = atoi (strtok (buffer, ","));
printf ("\nNome: %s", ItemAux.Time.nome);
ItemAux.Time.classificacao = atoi (strtok (buffer, ","));
printf ("\nClassificacao: %d", ItemAux.Time.classificacao );
ItemAux.Time.pontos = atoi(strtok (NULL, ","));
printf ("\nPontuacao: %d", ItemAux.Time.pontos);
fgets (buffer, 100, ArqRanking);
}
}
/************************ LEITURA DA ENTRADA *******************************/
while (!feof(ArqEntrada)){
Acao = strtok (NULL, ",");
if (strcmp("CONSULTA", Acao)==0){
TipoDaAcao = atoi (strtok (buffer, ","));
NomeDoTime1 = atoi (strtok (buffer, ","));
//if (pesquisarTime(&Campeonato, *NomeDoTime1, ItemAux )==0){
if (1){
printf("/nERRO: Time nao encontrado para consulta.");
}
if (strcmp("PONTUACAO", Acao)==0){
fprintf(ArqSaida, "%s,%s,%d", TipoDaAcao, NomeDoTime1, ItemAux.Time.pontos);
}
else if (strcmp("RANKING", Acao)==0){
fprintf(ArqSaida, "%s,%s,%d", TipoDaAcao, NomeDoTime1, ItemAux.Time.classificacao);
}
}
else if(strcmp("VITORIA", Acao)==0){
NomeDoTime1 = atoi (strtok (buffer, ","));
NomeDoTime2 = atoi (strtok (buffer, ","));
if (1){//*pesquisarTime(*NomeDoTime1, Campeonato, ItemAux )*/){
atualizaVitoria(Campeonato, *Item, p);
}
else if(1){ //(pesquisarTime(*NomeDoTime1, Campeonato, ItemAux )==0){
//Como somar os 3 pontos para inserir ordenado?
inserirOrdenado(Campeonato p, *Time);
}
if (1){ //(pesquisarTime(*NomeDoTime2, Campeonato, ItemAux )==0){
inserirOrdenado(Campeonato p, *Time);
}
/* else if(strcmp("EMPATE", Acao)==0){
NomeDoTime1 = atoi (strtok (buffer, ","));
NomeDoTime2 = atoi (strtok (buffer, ","));
/* pesquisarTime retorna 1 se o time for encontrado e 0 se não.
if (pesquisarTime(*NomeDoTime1, Campeonato, ItemAux )){
atualizaEmpate(Campeonato, *Item, p);
}
/* pesquisarTime retorna 1 se o time for encontrado e 0 se não.
else if (pesquisarTime(*NomeDoTime1, Campeonato, ItemAux )==0){
//Como somar o 1 ponto para inserir ordenado?
inserirOrdenado(Campeonato p, *Time);
}
/* pesquisarTime retorna 1 se o time for encontrado e 0 se não.
if (pesquisarTime(NomeDoTime2, Campeonato, ItemAux )){
atualizaEmpate(Campeonato, *Item, p);
}
/* pesquisarTime retorna 1 se o time for encontrado e 0 se não.
else if (pesquisarTime(*NomeDoTime2, Campeonato, ItemAux )==0){
//Como somar o 1 ponto para inserir ordenado?
inserirOrdenado(Campeonato p, *Time);
}
*/
}
else{
printf("/nErro: Primeiro argumento invalido.");
}
}
/************************ IMPRIME RANKING *******************************/
ImprimeNoArquivoDeSaida(Campeonato);
fclose(ArqEntrada);
fclose(ArqSaida);
fclose(ArqRanking);
return 0;
}Fiz o código desta maneira porém estou com muitas duvidas quanto as passagens dos parâmetros para as funções. Vocês podem me ajudar ? Obrigado
