Problema con Debugger

Salve, ho scritto un codice per la simulazione della visita di un albero. In input ho un array di struct con due campi ossia ELEMENTO e PADRE.

Da questo input formo la struttura del mio albero, creando una tabella che visualizza l'elemento, il grado e l'indice in cui si trovano i rispettivi figli.

Da questa tabella parto dalla radice (sarebbe l'elemento con padre -1) e visito tutto l'albero tramite l'utilizzo di una coda.

Ecco il codice:

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

#define ELEM 11

struct input{
       char e;
       short padre;
       };

struct albero{
       char inf;
       short grado;
       short *figli;
       };
       
struct coda{
       short elemento;
       struct coda *p_next;
       };
       
typedef struct input INPUT;
typedef struct albero ALBERO;

short conta_max_figli(INPUT x[]); //funzioni
void forma_struttura(INPUT x[], ALBERO y[], short *radice);
void lettura_albero(ALBERO y[], short radice);

struct coda *crealista();
void elim_testa(struct coda **head);
void ins_nodo(short dato, struct coda **punt);


void main()
{
     INPUT x[ELEM]={{'E',-1},
                    {'A',0},
                    {'E',0},
                    {'R',0},
                    {'A',1},
                    {'T',3},
                    {'E',5},
                    {'S',1},
                    {'M',5},
                    {'L',5},
                    {'P',5}};
                  
     ALBERO y[ELEM]={{' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0},
                     {' ',0}};
                   
     short max,i,j,radice;
     
     max=conta_max_figli(x); //conto numero maggiore di figli
     
     for(i=0;i<ELEM;i++)
     y[i].figli=calloc(max,sizeof(short)); //alloco memoria al vettore figli inizializzando a 0 
     
     
     
     forma_struttura(x,y,&radice); //formo la struttura dell'albero
     
     //visualizzo la struttura
     printf("     N | G | F | F | F | F\n");
     printf("--------------------------\n");
     for(i=0;i<ELEM;i++)
     {
         if(i==10)
         printf("%d| ",i);
         else
         printf("%d | ",i);
         
         printf(" %c | %d ",y[i].inf,y[i].grado);
         for(j=0;j<4;j++)
             printf("| %d ",y[i].figli[j]);
             
         printf("\n");
     }
     
     printf("\n\n"); system("pause"); 
     
     printf("\n\nEcco l'albero completo: \n\n");
     
     lettura_albero(y, radice); //leggo l'albero
     
     
     printf("\n\n"); system("pause");   
 
}

short conta_max_figli(INPUT x[]) //funzione per calcolare il numero massimo di figli
{
     short max_figli=0, figli;
     short i,z;
     
     for(i=0;i<ELEM;i++) 
     {
         z=0; 
         figli=0;
         while(z<ELEM) //parto dalla radice e verifico dal primo fino all'ultimo
         {
             if(x[z].padre==i) figli++; //se il padre è uguale all'indice memorizzato incremento di uno i figli
             z++;
         }
         if(figli>max_figli) max_figli=figli; //se il numero di figli è maggiore del numero massimo dei figli aggiorno
     }
     
     return max_figli;
}

void forma_struttura(INPUT x[], ALBERO y[], short *radice) //questa funzione mi forma la struttura dell'albero
{
     short i;
     
     for(i=0;i<ELEM;i++) 
     {
         y[i].inf=x[i].e;
         
         if(x[i].padre==-1) //mi salvo la radice dell'albero
             radice=i;         
         else
         {
             y[x[i].padre].figli[y[x[i].padre].grado]=i;
             y[x[i].padre].grado++;
         }
     }
}

void lettura_albero(ALBERO y[], short radice) //funzione che mi visualizza l'albero con la coda
{
     struct coda *head,*punt;
     short i,el=0;    
     
     head=crealista(); 
     head=calloc(1,sizeof(struct coda));
     head->elemento=radice; //inserisco la radice come primo elemento
     el++;   
     punt=head;
     while(el>0) //while fino a che coda non è vuota
     {
         printf("%c ",y[head->elemento].inf); //visualizzo la testa della coda
         for(i=0;i<y[head->elemento].grado;i++) //for che mi scorre tutti i figli
         {
             ins_nodo(y[head->elemento].figli[i],&punt); //inserisco i figli nella coda
             el++; //aumento elementi
         }                             
         elim_testa(&head); //elimino la testa della coda
         el--; //diminuisco elementi
     }         
}

struct coda *crealista()
{
       struct coda *testa;
       testa=NULL;
       return testa;
}

void elim_testa(struct coda **head)
{
     *head=(*head)->p_next; 
}

void ins_nodo(short dato, struct coda **punt)
{
     struct coda *ptr;
     ptr=calloc(1,sizeof(struct coda));
     ptr->elemento=dato;
     ptr->p_next=(*punt)->p_next;
     (*punt)->p_next=ptr;
     *punt=ptr;
}

Quando avvio il programma non mi vengono stampati gli elementi dell'albero:



A questo punto ho usato il DEBUGGER per trovare l'errore ma il programma mi ha stampato questo output:



In poche parole avviandolo normalmente il programma non mi funziona, mentre usando il debugger il programma funziona bene

Il problema è che non riesco a capire come sia possibile.. L'esecuzione è la stessa.. A cosa è dovuto questo tipo di errore? Non mi è mai capitato prima..

Grazie per eventuali risposte..