Jump to content
Fórum Script Brasil
  • 0

Inserir ordenado na lista encadeada(ligada)


otaviohpf
 Share

Question

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 

Link to comment
Share on other sites

0 answers to this question

Recommended Posts

There have been no answers to this question yet

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share

  • Forum Statistics

    • Total Topics
      149.6k
    • Total Posts
      646.2k
×
×
  • Create New...