Stos na dynamicznej tablicy C

Witam witam. Musiałem napisać stos o dynamicznej pamięci na tablicy jednowymiarowej. Napisałem coś takiego i w sumie w Dev C++ działa aczkolwiek już nie do końca na Ubuntu. Zajrzycie i ocenicie co jest nie tak i co można by poprawić?

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

#define INITIAL_STACK_SIZE 4

struct stack
{
    int top;
    int *data;
    int size;
};

typedef struct stack Stack;



void init(Stack* s);
void destroy(Stack* s);
void push(Stack* s, int _element);
int pop(Stack* s);
void clear(Stack* s);
bool isEmpty(Stack* s);


int main()
{
    int wybor, element, *nowy;
    Stack *s = (Stack*)malloc(sizeof(Stack));
   
    init(s);
   
    printf(" 1 - Push\n 2 - Pop\n 3 - isEmpty\n 4 - Destroy\n 5 - Clear\n 6 - Ponowne zainicjalowanie stosu\n 7 - End\n ");
    do
    {       
        scanf("%d",&wybor);
            switch(wybor)
            {
                case 1:
                    printf("Podaj wartosc elementu ktory chcesz dodac do stosu: \n");
                    scanf("%d",&element);
                    push(s, element);
                    break;
           
                case 2:
                    printf("%d\n",pop(s));
                    break;
               
                case 3:
                    if(isEmpty(s) == true)
                        printf("Stos jest pusty!\n");
                    else
                        printf("Stos nie jest pusty!\n");   
                    break;
               
                case 4:
                    destroy(s);
                    printf("Stos zostal usuniety. Zeby uzyc go ponownie musisz uzyc najpierw funkcji init()!\n");
                    break;
               
                case 5:
                    clear(s);
                    printf("Stos jest pusty!\n");
                    break;
               
                case 6:
                    init(s);
                    printf("Stos ponownie zainicjalizowany!\n");
                    break;
                   
                case 7:
                    printf("Koncze program!");
                    destroy(s);
                    break;
                default:
                    printf("Zly wybor, dokonaj go jeszcze raz!\n");
                    break;
            }
        fflush(stdin);
    }while(wybor!=6);
   
   
    return 0;
}

void init(Stack* s)
{
    s->top = -1;
    s->data = (int*)malloc(INITIAL_STACK_SIZE * sizeof(int));
    if(s->data == NULL)
    {
        printf("Blad alokacji pamieci!\n");
        abort();
    }
    s->size = INITIAL_STACK_SIZE;
}

void push(Stack* s, int _element)
{
    if(s->top + 1 < s->size)
    {   
        s->top += 1;
        s->data[s->top] = _element;
    }
    else
    {

        s->data = (int*)realloc(s->data, 2 * sizeof(s->data));
        if(s->data == NULL)
        {
            printf("Blad alokacji pamieci!\n");
            destroy(s);
            abort();
        }
        s->size *= 2;
        s->top += 1;
        s->data[s->top] = _element;

    }
    printf("Element dodany!\n");
}

int pop(Stack* s)
{
    int nr;
    if(s->top == -1)
        printf("Blad! Stos jest pusty!\n");
       
    else
    {
        nr = s->data[s->top];
        s->data[s->top] = NULL;
        s->top -= 1;
        return nr;
    }   
}

void clear(Stack* s)
{
    int i ;
   
    for(i = s->top; i >= 0; s->top --, i--)
    {
        printf("%d\n", i);
        printf("Zawartosc przed %d\n",s->data[s->top]);
        s->data[s->top] = NULL;
        printf("Zawartosc %d\n \n",s->data[s->top]);
    }
       
}

bool isEmpty(Stack* s)
{
    if(s->top == -1)
        return true;
    else return false;
}

void destroy(Stack* s)
{
    clear(s);
    free(s->data);
    s->size = INITIAL_STACK_SIZE;
    s->top = -1;
}    

s->data = (int*)realloc(s->data, 2 * sizeof(s->data));

tu na pewno jest rozbieżność pomiędzy intencjami a wykonaniem....