Zamiana miejscami dwóch elementów ze szczytu listy

Mam takie pytanko. Jak sprawić, żeby funkcja pop zwracała wartość zdejmowanego elementu ze stosu(listy jednokierunkowej) ? Z góry dzięki ;)

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


/*Dynamiczna lista jednokierunkowa-stos*/
typedef struct elem
{
    int i;  /* liczba */
    struct elem *nastepny;
} lista;


/*****************************************************************************/
 void pop(lista **stos,int element)  /*wylacza pierwszy element z listy*/
{
    lista *a;
    if(stos!=NULL)
    {
        a=*stos;
        element=a->i;
        *stos=a->nastepny;
        free(a); /*kasowanie elementu ze zwolnieniem pamieci dynamicznej*/
        a = NULL; /*Przypisanie wskaznikowi wartosci NULL ułatwia wykrywanie pózniejszych
                   błednych odwołan do skasowanego elementu pamieci*/
        printf("Poprawnie zdjeto element ze stosu\n");
        
    }
    else
    {
        fprintf(stderr,"Blad: BRAK DANYCH !!!\n");
    }
}

/************************************************************/

Dobra. Zmiana typu funkcji na int pomogła :D

Teraz pojawił się inny problem. Ktoś wie czemu taka oto funkcja nie działa poprawnie ????????:

 /************************************************************/
/*Funkcja zamieniajaca miejscami dwa elementy ze szczytu '$'*/

void zamien()
{
    lista *stos=NULL;
    int x, y;
    int element=0;
    
    x=pop(&stos, element);
    y=pop(&stos, element);
    push(&stos,x);
    push(&stos,y);
    
}

/************************************************************/

Probujesz operować na nullu.

lista *stos=NULL;
...
x=pop(&stos, element);

Czego oczekujesz dostać z pustego stosu?

Poza tym dużo poważniejszy błąd jest w pop

if(stos!=NULL)
{
    a=*stos;
    element=a->i;

Sprawdziłeś jedynie, że stos nie jest nullem, ale przecież a może być nullem (co jest dokładnie tym przypadkiem w zamien).
W tym momencie wołanie element=a->i; to UB.

Jak zatem proponujecie rozwiązać ten problem ?

Więc po kilku godzinach kombinowania udało mi się sprawić, aby funkcja zamien dzialala poprawnie. Wszystko byloby dobrze, ale funkcja duplikuj nadal nie dziala:

/*#############################################################*/
/*################ Funkcje do obslugi stosu ###################*/
// opcje.c
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct elem
{
    int i;  /* liczba */
    struct elem *nastepny;
} t_elem;
 
 
/**************************************************************/
/*Funkcja dodajaca liczbe na stos 'p'*/
 
void push(t_elem **stos, int element)
{
    t_elem *lista;
    lista=(t_elem*)malloc(sizeof(t_elem)); /* utworz element */
     
    if(lista==NULL)
    {} /* nie rob nic */
    else
    {
        lista -> i=element;  /*przypisanie do komorki stosu pobranej wartosci czyli liczby(i)*/
        lista->nastepny=*stos;   /*przypisanie liczby(i) do stosu*/
        *stos=lista;
        printf("Poprawnie dodano element na stos\n");
    }
}
 
/*************************************************************/
/*Funkcja zdejmująca element ze szczytu stosu '#'*/
 
int pop(t_elem **stos,int *element)
{
    t_elem *wsk; /* pomocniczy wskaznik */
    if(stos!=NULL)
    {
        wsk=*stos;
        *element=wsk->i;
        *stos=wsk->nastepny;
        free(wsk); /*kasowanie ze zwolnieniem pamieci dynamicznej*/
        wsk=NULL; /*Przypisanie wskaznikowi wartosci NULL ułatwia wykrywanie pózniejszych
         błednych odwołan do skasowanego elementu pamieci*/
        printf("Poprawnie zdjeto element ze stosu\n");
         
    }
    else
    {
        fprintf(stderr,"Blad: BRAK DANYCH !!!\n");
    }
    return *element;
}
 
/************************************************************/
/*Funkcja wyswietlajaca na wyjscie cały stos '?'*/
 
void print(t_elem *stos)
{
    if(stos==NULL)
        printf("Na stosie nie ma zadnej liczby\n");
    else
        printf("Elementy znajdujace sie na stosie:\n");
        while (stos!=NULL)
        {
            printf("%d\n",stos->i);
            stos=stos->nastepny;
        }
}
 
/************************************************************/
/*Funkcja sprawdzająca czy stos nie jest pusty 'e'*/
void empty(t_elem *stos)
{
    if(stos==NULL)
        printf("Stos jest pusty\n");
    else
        printf("Stos nie jest pusty\n");
}
 
/************************************************************/
/*Funkcja zamieniajaca miejscami dwa elementy ze szczytu '$'*/
 
void zamien()
{
    t_elem *stos;
    int x, y;
    int element;
    
    x=pop(&stos, &element);
    y=pop(&stos, &element);
    push(&stos,x);
    push(&stos,y);
}
 
/************************************************************/
/*Funkcja duplikujaca element na szczycie stosu '&'*/
 
void duplikuj()
{
    t_elem *stos;
    int element;
    int x;
     
    x=pop(&stos, &element);
    push(&stos,x);
    push(&stos,x);
}
 
/************************************************************/
 
 
 
int main()
{
    t_elem *stos=NULL;
    char wybor[2]; /* jest jeszcze znak konca linii \0 */
    int element=0;
     
    printf("Dostepne operacje:\n ? - wyswietl liczby znajdujace sie "
    "na stosie\n p - dodaj liczbe na szczyt stosu\n # - usun liczbe"
    " ze szczytu stosu\n e - sprawdz czy stos jest pusty\n $ - zamien miejscami"
    " dwa elementy ze szczytu stosu\n & - duplikuj element ze szczytu stosu\n"
    " q - wyjscie z programu\n");
 
    while(wybor[0]!='q')
    {
        printf("Twoj wybor: ");
        scanf("%s",&wybor[0]);
        if(wybor[0]=='e' || wybor[0]=='?' || wybor[0]=='p'
           || wybor[0]=='#' || wybor[0]=='$' || wybor[0]=='&' || wybor[0]=='q')
        {
            switch(wybor[0])
            {
                case '?':
                    print(stos);
                    break;
                case 'p':
                    printf("Podaj liczbe: ");
                    scanf ("%d",&element);
                    push(&stos,element);
                    break;
                case '#':
                    pop(&stos,&element);
                    break;
                case 'e':
                    empty(stos);
                    break;
                case '$' :
                    zamien();
                    break;
                case '&' :
                    duplikuj();
                    break;
            }
        }
        else
        {
            fprintf(stderr, "Blad: NIEZNANA OPERACJA !!!\n");
        }
    }
    printf("Program zakonczyl dzialanie\n");
    return 0;
}

void duplicate( t_elem** stack ) {
  if( *stack ) {
    push( stack, (*stack)->i );
  }