Inserir ordenado na lista encadeada(ligada)

[otaviohpf]

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