C/C++ - Gestione coda generica

Ho scritto un programma per la gestione di una coda e di una pila generica.
L'inizio dei due codici è uguale, ma la pila funziona e la coda no!
Nel codice riguardante la coda, inserisco il primo elemento, che ovviamente, in quanto primo, deve essere inserito in testa. Ma il programma, a quel punto va in crash!
Diversamente il codice sulla pila, che è il medesimo almeno all' inizio, funziona senza problemi.
Li posto entrambi:

Pila (funzionante)

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

typedef struct elem {
    struct elem* next;
    void* key;
} elem;

elem* ins (elem*,void*,void*(*copia)(void*));
void* copia (void*);
elem* crea ();
void stampa (elem*);
elem* del_testa(elem*);

int num = 0;    // variabile globale
main (){
    void* n;
    elem* head;
    int r;


    while (1) {
        printf ("1. Push\n2. Pop\n3. Esci\n- ");
        scanf ("%d",&r);

        if (r == 1) {
           if (num < 10) {
            printf ("numero da inserire in testa: ");
            int insert;
            fflush(stdin);
            scanf ("%d",&insert);
            n = &insert;                    // inserisce in *numero in variabile generica
            *(int*) n = insert;             // casting con il tipo Intero

            head = ins (head,n,copia);
            num++;

            stampa (head);
            puts ("");
            } // fine IF *num 10

           else puts ("Stack pieno");
        } // fine IF

        else if (r == 2) {
           if (num > 0) {
            head = del_testa(head);         // eliminazione in testa
            stampa (head);
            puts ("");
            num--;
         } // fine IF *num 0
          else puts ("Stack vuoto");
        } // fine ELSE IF

        else if (r == 3) exit (1);
        else puts ("Non valido\n");
    } //fine WHILE INFINITO
}

elem* ins (elem* head,void* k,void*(*copia)(void*)) {
    elem* temp;
    temp = malloc(sizeof(elem));
    temp->next = head;
    temp->key = copia (k);  // funzione per copiare intero
    return temp;
    }

void* copia (void* a) {
    int* temp;
    if ((temp = malloc(sizeof(int))) == NULL) return NULL;  // se ERRORE
    *temp = *(int*) a;
    return (void*) temp;
    }


void stampa (elem* head) {
    elem* cur;
    cur = head;
    puts ("\nLISTA");

    while (cur->next != NULL) {
    int t = *(int*)cur->key;        // deve mostrare un tipo INTERO
    printf ("%d\n",t);
    cur = cur->next;
    }
}

elem* del_testa (elem* head) {
    head = head->next;
    return head;
}

Coda (crash al primo inserimento)

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

typedef struct elem {
    struct elem* next;
    void* key;
} elem;


elem* ins_testa (elem*,void*,void*(*copia)(void*));
void* copia (void* a);
elem* ins_coda (elem*,void* ,void*(*copia)(void*));
elem* scorri (elem*);
elem* del_testa (elem*);
void stampa (elem*);


main (){
    void* n;
    elem* head;
    int r;
    int num = 0;

    printf ("Inserire il primo elemento: ");
            int insert;
            fflush(stdin);
            scanf ("%d",&insert);
            n = &insert;                    // inserisce in numero in variabile generica
            *(int*) n = insert;             // casting con il tipo Intero

            head = ins_testa (head,n,copia);
            num++;

            //stampa (head);
            puts ("");

    while (1) {

        printf ("1. Push\n2. Pop\n3. Esci\n- ");
        scanf ("%d",&r);

        if (r == 1) {
            if (num < 10) {
            printf ("Numero da inserire in coda: ");
            int insert;
            fflush(stdin);
            scanf ("%d",&insert);
            n = &insert;                    // inserisce in numero in variabile generica
            *(int*) n = insert;             // casting con il tipo Intero

            elem* corrente;
            corrente = scorri (head);       // ultimo elemento lista
            head = ins_coda (corrente,n,copia);
            num++;

            puts ("");
            } // fine IF

            else puts ("Stack pieno");
            }   // fine CASE 1

        else if (r == 2) {
            if (num > 0) {
                head = del_testa(head);

                puts ("");
                num--;
                } // fine IF NUM > 0
                else puts ("Stack vuoto");
                           } // fine ELSE IF CASE 2

        else if (r == 3) exit (1);
        else if (r == 4) stampa (head);
        else puts ("Non valido\n");
        }   // FINE WHILE INFINITO
}


elem* ins_testa (elem* head,void* k,void*(*copia)(void*)) {
    elem* temp;
    temp = malloc(sizeof(elem));
    temp->next = head;
    temp->key = copia (k);  // funzione per copiare intero
    return temp;
    }

void* copia (void* a) {
    int* temp;
    if ((temp = malloc(sizeof(int))) == NULL) return NULL;  // se ERRORE
    *temp = *(int*) a;
    return (void*) temp;
    }


elem* ins_coda (elem* corrente,void* k,void*(*copia)(void*)) {
    elem* temp;
    temp = malloc(sizeof(elem));
    temp->key = copia(k);
    corrente->next = temp;
    temp->next = NULL;
    return temp;
    }


elem* scorri (elem* head) {
    elem* cur;
    cur = head;

    while (cur != NULL) {
    cur = cur->next;
    }

    head = cur;
    return head;
}

elem* del_testa (elem* head) {
    head = head->next;
    return head;
}

void stampa (elem* head) {
    elem* cur;
    cur = head;
    puts ("\nLISTA");

    while (cur->next != NULL) {
    int t = *(int*)cur->key;        // deve mostrare un tipo INTERO
    printf ("%d\n",t);
    cur = cur->next;
    }
}

Tra le altre cose, per qualche motivo ho dovuto usare una serie di if piuttosto che lo switch.
Se qualcuno riuscisse a capire il perchè del crash, gli sarei grato.

Beh, tanto per cominciare scriverei

elem* head = NULL;

... per il resto c'è da controllare ...