Inserir ordenado na lista encadeada(ligada)

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