Mi funcion de borrar falla

[Evox4]

Me falla la funcion de borrar en mi lista doblemente ligada circular, que puede ser?

Código (c) [Seleccionar] Expandir

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

enum opcion {EXIT,INSERT,FIND,DELETE,SHOW,CURR,NEXT,PREV,FINDPREV,FINDNEXT};

struct nodo {
    char nombre[40];
    struct nodo *next;
    struct nodo *prev;
};

int numNodos;
int pos;
struct nodo *head, *tail;


struct nodo *crearNodo () {
    struct nodo *x;
     
    x= (struct nodo *) malloc (sizeof (struct nodo));
    printf ("Nombre: ");
    gets (x->nombre);
    x->next=NULL;
    x->prev=NULL;
    numNodos++; 
    return x;
}
struct nodo *buscar_ant (struct nodo *act) {
    char *k= act->nombre;
     
    if (act == NULL) return NULL;

    act= act->prev;
    while (act) {
        if (strcmp (act->nombre,k) == 0)
            break;
        act= act->prev;
    }
    return act;
}
struct nodo *buscar_sig (struct nodo *act) {
    char *k= act->nombre;
     
    if (act == NULL) return NULL;

    act= act->next;
    while (act) {
        if (strcmp (act->nombre,k) == 0)
            break;
        act= act->next;
    }
    return act;
}

struct nodo *buscar (struct nodo *lista, char *k) {
   system("cls");
     struct nodo *actual;
     char aux [40];
     int p = 1;
     int encontrado = 0;
     
        actual = lista;
        system("cls");
        printf("\n Indique nombre a buscar    ");
        fflush(stdin);
        gets(aux);
        system("cls");
        while (p <= numNodos)
           { 
            if(strcmp(aux, actual->nombre)==0)
                    {
                      printf("\n %s  EXISTE", aux );
                      encontrado = 1;
                    }
                      p++;
                      actual = actual->next;
           }                                                                                       
   if (encontrado==0)   
      printf("\n %s NO EXISTE", aux );
                                                                                                                                                                                                                                   
   printf("\n\n\n\n\n\n\n");                                                                     
   system("pause");       
}


// operacion eliminar: elimina el primer nodo que coincida con la llave k
// recibe referencia del apuntador al inicio de la lista y llave a eliminar
// devuelve el nodo eliminado o null si no se encuentra el nodo

struct nodo *borrar (struct nodo *lista, char *k) {
   system("cls");
    struct nodo  *aux;
    struct nodo  *actual;
    int nodo_eliminar;
    int x;
   
    printf("\n Indique la posición del nombre  a eliminar    ");
    scanf(" %d", &nodo_eliminar);
    if(nodo_eliminar > numNodos || nodo_eliminar < 1)
       printf("ELEMENTO INEXISTENTE");
       
    if(nodo_eliminar == 1) {
       aux = lista;
       lista = lista->next;
       if(lista == NULL)
          tail = NULL;
         
    else
      lista->prev == tail;
       }
       else if(nodo_eliminar == numNodos)
       {
          aux = tail;
          tail->prev->next = tail;
          tail = tail->prev;
       }else {                                                                                                                                                                                                                     
             actual = tail;
             for(x=1; x<nodo_eliminar;++x)
               actual = actual->next;
             aux = actual;
             actual->prev->next = actual->next;
             actual->next->prev = actual->prev;
   }
   free(aux);
   numNodos--; 
}

void listar (struct nodo *lista) {
    system("cls");
     
     struct nodo *actual;
     pos=1;
     actual=lista;
     while(pos<=numNodos)
       {
          printf("<-%s->", lista->nombre);
          lista= lista->next;
          pos++;
       }
       if(numNodos==0)
           printf("\n LISTA VACIA");
       printf("\n\n\n\n\n\n\n");
       system("pause");   
}

struct nodo *insertar (struct nodo *head, struct nodo *x) {
    if (head != NULL) {
        head->prev= x;       // El antecesor al primer nodo de la lista apunta al nuevo nodo
        x->next= head;       // El sucesor del nuevo nodo apunta al primer nodo de la lista
    }
    head= x;                // El inicio de la lista apunta al nuevo nodo
     
    return head;
}
struct nodo *curr (struct nodo *actual) {
    if (actual) {
        printf ("%s\n",actual->nombre);
        return actual;
    }
    printf ("No hay nodo actual\n");
     
    return actual;
}
struct nodo *prev (struct nodo *actual) {
    if (actual && actual->prev) {
        printf ("%s\n",actual->prev->nombre);
        return actual->prev;
    }
    printf ("No hay nodo anterior\n");
     
    return actual;
}

struct nodo *next (struct nodo *actual) {
    if (actual && actual->next) {
        printf ("%s\n",actual->next->nombre);
        return actual->next;
    }
    printf ("No hay nodo siguiente\n");
     
    return actual;
}

int main ()
{
    char nombre[40];
    enum opcion op= EXIT;
    struct nodo *x,*act=NULL;
    struct nodo *head= NULL;
    struct nodo *tail= NULL;
    struct nodo *lista;
     char aux [40];
     int p = 1;
     int encontrado = 0;
     
    while (1) {
        system ("cls");
        printf ("1. Insertar\n");
        printf ("2. Buscar\n");
        printf ("3. Borrar\n");
        printf ("4. Listar\n");
        printf ("5. Actual\n");
        printf ("6. Siguiente\n");
        printf ("7. Anterior\n");
        printf ("8. Buscar anterior\n");
        printf ("9. Buscar siguiente\n");
        printf ("0. Salir\n");
        printf ("\nOpcion: ");
        scanf ("%d", &op);
        fflush (stdin);

        switch (op) {
            case INSERT:
                x= insertar (head,crearNodo ());
                if (head == NULL)   // No hay nodos
                tail= x;
                head= x;        // Head apunta al nuevo nodo
                tail->next= head;    // Siguiente del ultimo nodo apunta al primer nodo
                head->prev= tail;    // Anterior del primer nodo apunta al ultimo nodo
                act= head;      // Nodo actual apunta a primer nodo
                break;
            case FIND:
        x= buscar (head,nombre);
                break;
            case DELETE:
                x= borrar (head,nombre);
                break;             
            case SHOW:
                listar (head);
                system ("pause");
                break;
            case CURR:
                curr (act);
                system ("pause");
                break;
            case NEXT:
                act= next (act);
                system ("pause");
                break;
            case PREV:
                act= prev (act);
                system ("pause");
                break;
            case FINDNEXT:
                x= buscar_sig (act);
                if (x != NULL) {
                    printf ("Se encuentro: %s\n", x->nombre);
                    act= x;
                }
                else
                    printf ("No se encuentra: %s\n", x->nombre);
                system ("pause");
                break;
            case FINDPREV:
                x= buscar_ant (act);
                if (x != NULL) {
                    printf ("Se encuentro: %s\n", x->nombre);
                    act= x;
                }
                else
                    printf ("No se encuentra: %s\n", x->nombre);
                system ("pause");
                break;
            case EXIT:
                return;
            default:
                printf ("Opcion invalida\n");
        }
    }       
     
}


Alguna idea?