Funçao Inserir em C - Nao entendo

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*****************************************Definições***************************************/
#define TAM_STRING 100
#define SEMENTE 500


/*****************************************Estruturas***************************************/
//Estrutura utilizada para armazenaros dados de uma aposta
typedef struct Aposta
{
	int iCodigoAposta;
	char strEstado[3];
	char strCidade[50];
	int vetNumeros[6];
	struct Aposta* ptProxima;
}stAposta;

//Estrutura utizada para definir uma lista de apostas
typedef struct Lista
{
	stAposta* ptInicio;
	stAposta* ptFim;
	int iTotal;
}stLista;


/****************************************Protótipos das funções****************************/
void mostraMenu(void);
void sorteiaNumeros(int*);
int jaSorteado(int*, int);
void leArquivo(stLista*);
stAposta* criaAposta(char *);
void insereApostaLista(stLista*, stAposta*);
void geraRelatorio(stLista*, int*);
void liberaMemoria(stLista*);

/*------------------------------------------------------------------------------------------
* Nome da função: main
* Descrição: Função principal de um programa em C
* Parâmetros: int, char**
* Retorno: int
------------------------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
	//Declaração das variáveis utilizadas
	stLista listaApostas;
	int iOpcao = 0;
	int vtNumerosSorteados[6];

	//Inicializando variáveis ponteiros da lista
	listaApostas.ptInicio = NULL;
	listaApostas.ptFim = NULL;
	listaApostas.iTotal = 0;
	
	//Configuração da semente utilizada no sorteio dos números
	srand(SEMENTE);

	//Loop do Menu
	while(iOpcao!=4)
	{
		//Mosta o menu principal
		mostraMenu();

		//Le a opcao
		scanf("%d",&iOpcao);

		//Chama as funções correspondentes
		if (iOpcao == 1)
		{
			//Chama a função para a leitura do arquivo e criação da lista de apostas
			leArquivo(&listaApostas);
		}
		else if (iOpcao == 2)
		{
			//Chama a função que realiza o sorteio dos números
			sorteiaNumeros(vtNumerosSorteados);
		}
		else if (iOpcao == 3)
		{
			//Chama a função que gera o arquivo de resultados
			geraRelatorio(&listaApostas, vtNumerosSorteados);
		}
	}

	//Chama a função que Libera a memória alocada dinamicamente
	liberaMemoria(&listaApostas);

	return 0;
}


/**************************************Implementação das funções****************************/
/*------------------------------------------------------------------------------------------
* Nome da função: mostraMenu()
* Descrição: esta função imprime o menu na tela
* Parâmetros: Nenhum
* Retorno: Nenhum
------------------------------------------------------------------------------------------*/
void mostraMenu(void)
{
    printf("\n  |------------------------------------------------|\n");
    printf("  |                                                |\n");    
    printf("  |            LOTERIAS TADS                       |\n");
    printf("  |                                                |\n");
    printf("  |------------------------------------------------|\n");
    printf("  |                                                |\n");
    printf("  |    <1> Ler Apostas                             |\n");    
    printf("  |    <2> Sortear numeros                         |\n");    
    printf("  |    <3> Gerar relatorio do sorteio              |\n");    
    printf("  |    <4> Sair                                    |\n");    
    printf("  |                                                |\n");    
    printf("  |------------------------------------------------|\n\n");    
    printf("\t\tOpcao: ");    
}

/*------------------------------------------------------------------------------------------
* Nome da função: leArquivo()
* Descrição: esta função realiza a leitura das apostas no arquivo e cria a lista de apostas
* Parâmetros: stLista*
* Retorno: Nenhum
------------------------------------------------------------------------------------------*/
void leArquivo(stLista* ptLista)
{
	//Declara a string responsável pelo armazenamento da linha lida do arquivo
	char strLinha[TAM_STRING];

	//Variável temporária para uma aposta
	stAposta* ptTmpAposta = NULL;

	//Realiza a abertura do arquivo
	FILE* ptArquivo = fopen("apostas.txt","rt");

	//Testa se o arquivo foi aberto com sucesso
	if (!ptArquivo)
	{
		printf("Arquivo de entrada nao pode ser aberto\n");
		return;
	}

	//Enquanto não for final de arquivo
	while(!feof(ptArquivo))
	{
		//Realiza a leitura de uma linha do arquivo
		fgets(strLinha,TAM_STRING,ptArquivo);

		//Extrai os dados da String lida do arquivo e preenche a estrutura da aposta
		ptTmpAposta = criaAposta(strLinha);

		//Insere uma aposta na lista dinâmica
		insereApostaLista(ptLista, ptTmpAposta);

		//Incrementa o total da apostas da lista
		ptLista->iTotal++;
	}

	//Fecha o arquivo
	fclose(ptArquivo);

	//Anula ponteiroS locais
	ptTmpAposta = NULL;
	ptArquivo = NULL;
}

/*------------------------------------------------------------------------------------------
* Nome da função: criaAposta()
* Descrição: esta função retira os dados de uma linha do arquivo e cria uma aposta
* Parâmetros: char*
* Retorno: stAposta*
------------------------------------------------------------------------------------------*/
stAposta* criaAposta(char* strLinha)
{
	//Declara um ponteiro para stAposta e variável auxiliar
	stAposta* ptTempAposta = NULL;
	int iIndice = 0;

	//Aloca memória para a estrutura  e inicializa o ponteiro
	ptTempAposta = (stAposta*)malloc(sizeof(stAposta));

	//Testa se a memória foi alocada
	if (!ptTempAposta)
	{
		printf("Nao foi possivel alocar a memoria");
		exit(1);
	}

	//Anula o ponteiro da estrutura
	ptTempAposta->ptProxima = NULL;

	//Quebra a string em tokens e atribui os valores para a estrutura
	ptTempAposta->iCodigoAposta = atoi(strtok(strLinha,";,/"));
	strcpy(ptTempAposta->strEstado,strtok(NULL,";,/"));
	strcpy(ptTempAposta->strCidade,strtok(NULL,";,/"));
	
	//Preenche o vetor de números
	for (iIndice=0; iIndice<6; iIndice++)
	{
		ptTempAposta->vetNumeros[iIndice] = atoi(strtok(NULL,";,/"));
	}
	
	//Retorna a estrutura preenchida
	return ptTempAposta;
}

/*------------------------------------------------------------------------------------------
* Nome da função: insereApostaLista()
* Descrição: esta função insere uma nova aposta na lista
* Parâmetros: stLista*, stAposta*
* Retorno: Nenhum
------------------------------------------------------------------------------------------*/
void insereApostaLista(stLista* ptLista, stAposta* ptAposta)
{

	[size=24][size=12]//Implemente aqui[/size][/size]



}

/*------------------------------------------------------------------------------------------
* Nome da função: sorteiaNumeros()
* Descrição: esta função sorteia 6 numeros entre 1 e 20
* Parâmetros: int*
* Retorno: Nenhum
------------------------------------------------------------------------------------------*/
void sorteiaNumeros(int* ptVetor)
{
	//Variaveis locais
	int iIndice = 0, iPosicao = 0, iAux = 0;

	//Realiza o sorteio
	for (iIndice=0; iIndice<6; iIndice++)
	{
		iAux = 1+rand()%20;

		//Numero sorteado já existe no vetor?
		while(jaSorteado(ptVetor,iAux))
		{
			iAux = 1+rand()%20;
		}

		//Atribui o valor sorteado
		ptVetor[iIndice] = iAux;
	}

	//Ordena os números do vetor (Bubble sort)
	for (iIndice=0; iIndice<6; iIndice++)
	{
		for (iPosicao=0; iPosicao<5-iIndice; iPosicao++)
		{
			if (ptVetor[iPosicao]>ptVetor[iPosicao+1])
			{
				iAux = ptVetor[iPosicao];
				ptVetor[iPosicao] = ptVetor[iPosicao+1];
				ptVetor[iPosicao+1] = iAux;
			}
		}
	}

	//Imprime numeros na tela
	for (iIndice=0; iIndice<6; iIndice++)
	{
		printf("%d ",ptVetor[iIndice]);
	}
}

/*------------------------------------------------------------------------------------------
* Nome da função: jaSorteado()
* Descrição: verifica se um número já está contido no vetor de números sorteados ou não
* Parâmetros: int*, int
* Retorno: int
------------------------------------------------------------------------------------------*/
int jaSorteado(int* ptVetor, int iNumero)
{
	//Variáveis locais
	int iIndice=0;

	//Passa pelo vetor verificando
	for (iIndice=0; iIndice<6; iIndice++)
	{
		if (ptVetor[iIndice] == iNumero)
		{
			return 1;
		}
	}

	return 0;
}

/*------------------------------------------------------------------------------------------
* Nome da função: geraRelatorio()
* Descrição: esta função cria um arquivo contendo um relatorio com os resultado obtidos
* Parâmetros: stLista*, int*
* Retorno: Nenhum
------------------------------------------------------------------------------------------*/
void geraRelatorio(stLista* ptLista, int* ptVetor)
{




	[size=24]//Implemente aqui[/size]





}

/*------------------------------------------------------------------------------------------
* Nome da função: liberaMemoria()
* Descrição: esta função libera a memória alocada dinamicamente para as apostas da lista
* Parâmetros: stLista*
* Retorno: Nenhum
------------------------------------------------------------------------------------------*/
void liberaMemoria(stLista* ptLista)
{
	//Variável temporária
	stAposta* ptTemp = NULL;

	//Verifica se a lista está vazia
	if (!ptLista || !ptLista->ptInicio)
	{
		return;
	}
	
	//Desaloca todos os nós da lista
	while (ptLista->ptInicio != NULL)
	{
		ptTemp = ptLista->ptInicio;
		ptLista->ptInicio = ptLista->ptInicio->ptProxima;
		free(ptTemp);
	}

	//Anula ponteiros
	ptLista->ptInicio = NULL;
	ptLista->ptFim = NULL;
	ptTemp = NULL;
}