Difficulty with cell array

Question

I have to create, in C, a program that receives a train of N wagons and rearranges these wagons in ascending order from 1 to N; To rearrange, K waiting rails are used (value informed by the user); These waiting rails, are stacks. That’s why I need to create a battery array.

I will post below what I have already done. The program is stopping when I try to access this array of cells.

I am using a TAD. So it follows in order my MAIN, then the FUNCTIONS and then the HEADERS used

********* MAIN *********

    main () {

    int n, num_trilhos, max, id, i, rep, aux;

    int j = 0;

    int k = 1;

    pilha **plh;

    lista *saida;

    fila *entrada;

    printf ("\n");

    printf ("**** SIMULADOR DO PROCESSO DE REARRANJO DE VAGOES ****\n");

    printf ("\nEntre com a quantidade de vagoes: ");

    scanf ("%d", &n);

    printf ("\nEntre com a quantidade inicial de trilhos de espera: ");

    scanf ("%d", &num_trilhos);


    if (n != 0)

{

    entrada = cria_fila ();

    saida = cria_lista ();

    plh = (pilha**)malloc(num_trilhos*sizeof(pilha*));


    for (i = 0; i < num_trilhos; i++)

    {

        plh[i] = cria_pilha ();

    }

    for (i = 0; i < n; i++)

    {

        id = rand () % n;

        /* rep = checa_repetido(entrada, id);
        /*
        if (rep == 0)
        {*/
        insere_fila (entrada, id);

        /*}
        else
        id = rand() % n;
        */
    }

    imprime_fila (entrada);


    while (entrada->ini != NULL)

    {

/* if (entrada->ini->id == 1)

        {

            insere_lista (saida, id);
            retira_vagao (entrada);
            continue;


        }

*/

        for (j = 0; j < num_trilhos; j++)

        {

            if (plh[j]->topo->id > entrada->ini->id && !pilha_cheia (plh[j]))   // Se o valor do elemento no topo da pilha e maior que o valor ser inserido, insere.
            {

                printf ("ok");
                push (plh[j], entrada->ini->id);
                retira_vagao (entrada);
                break;

            }

            else if (plh[j]->topo->id == NULL)

            {

                push (plh[j], entrada->ini->id);
                retira_vagao (entrada);
                break;

            }

            else

            plh[num_trilhos + k] = cria_pilha ();   // Caso tenha encerrado a quantidade de pilhas, cria mais uma
            num_trilhos++;

            push (plh[j + k], entrada->ini->id);
            retira_vagao (entrada);
            break;

        }

    }


    printf ("\n");

    free (saida);

    libera_pilha (plh);

    libera_fila (entrada);

}

else

    printf ("Entrar com numero de vagoes valido");

return 0;

}

    ********** FUNÇÕES ***********

#include <stdio.h>
#include <stdlib.h>
#include "headers.h"
#define TamMax 3


fila *cria_fila ()
{
    fila *novo = (fila *) malloc (sizeof (fila));
    novo->ini = novo->fim = NULL;
    return novo;
}

pilha *cria_pilha ()
{
    pilha *novo = (pilha *) malloc (sizeof (pilha));
    novo->topo = NULL;
    return novo;
}

vagao *cria_vagao (int id)
{
    vagao *novo = (vagao *) malloc (sizeof (vagao));
    novo->prox = NULL;
    novo->id = id;
    return novo;
}

lista *cria_lista (void)
{
    return NULL;
}

lista *insere_lista (lista * l, int id)
{
    lista *novo = (lista *) malloc (sizeof (lista));
    novo->info = id;
    novo->prox = l;
    return novo;
}

void insere_fila (fila * f, int id)
{
    vagao *novo = cria_vagao (id);
    if (f->fim == NULL)
    {
        f->ini = f->fim = novo;
    }
    else
    {
        f->fim->prox = novo;
        f->fim = novo;
    }
}

void libera_fila (fila * f)
{
    vagao *aux;
    while (f->ini != NULL)
    {
        aux = f->ini;
        f->ini = f->ini->prox;
        free (aux);
    }
    free (f);
}

void push (pilha * p, int id)
{
    vagao *novo = cria_vagao (id);
    if (p->topo == NULL)
    {
        p->topo = novo;
    }
    else
    {
        novo->prox = p->topo;
        p->topo = novo;
    }
}

void pop (pilha * p)
{
    vagao *aux;
    if (p->topo == NULL)
    {
        return;
    }
    else
    {
        aux = p->topo;
        p->topo = p->topo->prox;
        free (aux);
        return;
    }
}

void libera_pilha (pilha * p)
{
    vagao *aux;
    if (p == NULL)
        return;
    while (p->topo != NULL)
    {
        aux = p->topo;
        p->topo = p->topo->prox;
        free (aux);
    }
    free (p);
}

void retira_vagao (fila * f)
{
    vagao *aux;
    aux = f->ini;
    f->ini = f->ini->prox;
    free (aux);
}

void imprime_fila (fila * f)
{
    while (f->ini->prox != NULL)
    {
        printf ("%d\t", f->ini->id);
        f->ini = f->ini->prox;
    }
}

int checa_repetido (fila * f, int id)
{
    while (id != NULL)
    {
        if (f->ini->id == id)
        {
            return 1;
            break;
        }
        else
            f->ini = f->ini->prox;
    }
    return 0;
}

void pilha_cheia(pilha* plh)
{
    if (plh->topo == TamMax)
    {
        printf("Pilha cheia\n");
    }
}
    *************** HEADERS ***************

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

    typedef struct Vagao vagao;
    typedef struct Pilha pilha;
    typedef struct Fila fila;
    typedef struct Lista lista;

    struct Vagao
    {
        int id;
        vagao *prox;
    };


    struct Pilha
    {
        vagao *topo;
    };


    struct Fila
    {
        vagao *ini, *fim;
    };

    struct Lista
    {
        int info;
        struct lista *prox;
    };

    lista *cria_lista();
    fila *cria_fila();
    pilha *cria_pilha();
    vagao *cria_vagao(int id);
    int checa_repetido (fila *f, int id);
    void insere_fila(fila *f, int id);
    void libera_fila(fila *f);
    void push(pilha *p, int id);
    void pop(pilha *p);
    void libera_pilha(pilha *p);
    void retira_vagao(fila *f);
    void imprime_fila(fila *f);

program popping memory when I try to access the array of batteries