Originariamente inviato da Ippo343
E come fai a sapere che è valido se non lo testi? ^^

Comunque, si, è giusta, ma io se fossi in te non modificherei il nodo:

codice:
lista sfrondalista(lista L)
{
    if (L == NULL) return NULL;

    lista nextN = L->next;

    if (L->dato < 0) 
        free(L);

    return sfrondalista(nextN);
}
Così è più semplice e più compatta
Quella funzione restituirà sempre e comunque NULL al programma chiamante, anche se non è stata deallocata tutta la lista; è dovuto al fatto che nel caso base si restituisce NULL, ma questo è il valore che restituiscono anche tutte le altre attivazioni della funzione fino alla prima. La penultima attivazione restituisce quello che restituisce l'ultima (NULL) quindi appunto NULL, la terzultima quello che restituisce la penultima (NULL) quindi di nuovo NULL e così via fino al programma chiamante.

Abbandonando l'idea di passare alla funzione un puntatore a puntatore per l'eliminazione in testa, che in questo caso è forse addirittura impossibile, la mia soluzione (provata in diversi casi e pare funzionante)

codice:
typedef struct _node {
  int dato;
  struct _node *next;
} node;

typedef node * node_ptr;

...

node_ptr erase(node_ptr head)
{
  node_ptr temp;
  
  /* caso base: fine lista */
  if (head == NULL) {
    return NULL;
  }
  
  /* caso generico */

  if (head -> next != NULL) {
    head -> next = erase(head -> next);
  }
  
  if (head -> dato < 0) {
    temp = head -> next;
    free(head);
    return temp;
  } else {
    return head;
  }
}
sembra complicata, ma con un po' di carta e penna risulta più o meno facile.

EDIT: il valore restituito dalla funzione al programma chiamante è il puntatore alla (eventualmente nuova) testa della lista. Se tutta la lista è stata deallocata perché tutti i valori sono minori di 0, allora la funzione restituisce correttamente NULL.