Simpler and faster code for reversing list?
Your code has some issues from my perspective.  The first that jumps out is that you are passing a pointer to a pointer to a list.   This is one level of indirection too many. Just pass a pointer to the list.  To make this easier, your list pointer in main() should just be a pointer to the first entry in the list; it should not be the first entry. In other words don't malloc space for a NODE in main().

So when you construct the list it will look like this:

 first _____
            |
            v
            -------       -------       -------       -------
  NULL &lt;-- |p      | &lt;--- |p     | &lt;--- |p     | &lt;--- |p     |
           |      n| ---&gt; |     n| ---&gt; |     n| ---&gt; |     n| ---&gt; NULL
            -------       -------       -------       -------


To reverse this list, you could take the approach given by @iaimtomisbehave, from earlier.  But this has two notable points: It needs a last pointer to the end of the list (this might be a plus) as well as first (or start/end); if you just swap last and first then you haven't really reversed the list because to traverse the list you now have to follow the prev pointers instead of following the next pointers. But there is a simple solution: just swap the prev and next pointers of each node as well as swapping first and last.

Some other points:


Naming: upper case names are usually reserved for constants. So call NODE something else: eg. Node or node.
malloc should not be cast
you malloced the string and then didn't use it.(Insert() line 5/6))
you have code to find the end of the list twice. It is a simple loop that belongs in a separate function.
Add some space to make the code look less cramped.  Note that while, for, if etc are special and deserve to be followed by an extra space: eg while (condition) (this is just my preference; others may disagree).
One variable per line.


That's enough I think :-) Here is my version of your program, for what it is worth.

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;

typedef struct Node
{
    char *item;
    struct Node *next;
    struct Node *prev;
} Node;

static Node *last_node(Node *list)
{
    while (list-&gt;next != NULL) {
        list = list-&gt;next;
    }
    return list;
}

static Node *insert(char *data, Node *list)
{
    Node *node = malloc(sizeof(Node));
    /* should handle malloc/strdup failure... */
    node-&gt;item = strdup(data);
    node-&gt;next = NULL;

    if (list == NULL) {
        list = node;
        node-&gt;prev = NULL;
    }
    else {
        Node *last = last_node(list);
        node-&gt;prev=last;
        last-&gt;next=node;
        last = node;
    }
    return list;
}

static Node *reverse(Node *list)
{
    Node *last = NULL;

    for (;list != NULL; list = list-&gt;prev) {
        Node *prev = list-&gt;prev;
        list-&gt;prev = list-&gt;next;
        list-&gt;next = prev;
        last = list;
    }
    return last;
}

static void display(const char *msg, Node *list)
{
    printf("%s\n", msg);

    for (;list != NULL; list = list-&gt;next) {
        if (list-&gt;prev != NULL) {
            printf("&lt;--&gt;");
        }
        printf("%s", list-&gt;item);
    }
    printf("\n");
}

int main(int argc, char ** argv)
{
    char s[50];
    Node *list = NULL;
    (void) argc;
    (void) argv;

    printf("Enter string of words for the list.  "
           "End the list with a full-stop on a blank line: ");
    while ((scanf("%49s", s) == 1) &amp;&amp; strcmp(s, ".")) {
        list = insert(s, list);
    }

    display("Original List is: ", list);
    list = reverse(list);
    display("Reversed List is: ", list);
    return 0;
}