Doubly linked list code in C
Some mostly stylistic improvements you could apply:


There is no need to cast the return value of malloc(), unless you plan on compiling this code as C++. In C, void* converts implicitly to any other pointer type. So the cast is just boilerplate in this case.
Prefer using sizeof(variable) instead of sizeof(Type). Example: 

Node *head = malloc(sizeof(*head));


This makes maintenance easier, since now if you introduce a new Node type, you only have to change one place, with no chance of updating one side of the expression and forgetting the other. Note that in this example, the dereference of head is valid because sizeof is a compile-time operation, so there is no actual pointer access taking place here, just type inference.
Consider giving more robust names to your functions. find(), insert(), etc, are very common names, which can apply to many things, not just lists. In C, you cannot overload function names, so in any major project, these names would be very likely to cause collisions with other global identifiers. Name prefixes are a common approach in C to solve this problem. Consider prefixing the function names with list_ or any other prefix you might prefer. I.e.:

void list_insert(Node *current, int data);
void list_delete(Node *current, int data);

Instead of returning an integer 0|1 to represent a boolean value, you can use the bool type, declared in the &lt;stdbool.h&gt; header, which is more idiomatic.
delete() function is a void function, so it doesn't need an explicit return statement at the end.
Looks like you are using printf() to log errors:


if(current-&gt;next == NULL) {
    printf("\nElement %d is not present in the list\n", data);
    return;
}



For error output, it is more correct to use fprintf and write to the stderr standard stream.
The list printing function print() could be made more flexible by receiving the output stream as a parameter. So you don't limit the caller to always printing to stdout, it can also be used to dump the list to a file (notice the use of fprintf()).

void print(Node *current, FILE *stream) {
    while(current != NULL) {
        fprintf(stream, "%d ", current-&gt;data);
        current = current-&gt;next;
    }   
}

When you want to allocate and immediately zero-initialize data, such as in here:


Node *head = (Node *)malloc(sizeof(Node));
head-&gt;next = NULL;
head-&gt;prev = NULL;



The standard function calloc() can be used to make code more concise:

Node *head = calloc(1, sizeof(*head));