Salve ragazzi sto studiando le liste collegate in C. Ho capito il concetto e alcuni semplici esempi ma il libro in cui studio ad un certo punto propone un esempio a cui non riesco a dare un senso. In pratica l'esercizio consiste nel creare una lista formata da strutture fatte da un char ed un puntatore a struttura, ogni volta che viene chiamata la funzione insert il programma dovrebbe creare un nuovo elemento della lista acquisire il nuovo carattere tramite tastiera e metterlo in ordine alfabetico nella lista. Il codice è il seguente:

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


struct Node
{
char data;
struct Node* next;
};


typedef struct Node Node;


void insert(Node** sPtr, char value);
char delete (Node** sPtr, char value);
int isEmpty(Node* sPtr);
void printList(Node* currentPtr);
void instructions(void);


int main (void)
{
Node* startPtr = NULL;
char item;


instructions();
unsigned int choice;
scanf("%u", &choice);


while(choice != 3)
{
switch(choice)
{
case 1:
printf("%s\n", "Enter a character: " );
scanf("%c", &item);
insert(&startPtr, item);
printList(startPtr);
break;


case 2:
if(!isEmpty(startPtr))
{
printf("%s\n", "Enter a character to be deleted: ");
scanf("%c", &item);


if(delete(&startPtr, item))
{
printf("%c deleted\n", item);
printList(startPtr);
}


else
{
printf("%c not found.\n\n", item);
}
}


else
{
puts("List is empty.\n");
}


break;


default:
puts("Invalid choice.\n");
instructions();
break;
}


scanf("%u", &choice);


}


puts("End of run.");
}


void instructions(void)
{
puts("Enter your choice.\n");
puts("1 to insert an element into the list.\n");
puts("2 to delete an element from the list.\n");
puts("3 to end.\n");
}


void insert(Node** sPtr, char value)
{
Node* newPtr = malloc(sizeof(Node));


if(newPtr != NULL)
{
newPtr->data = value;
newPtr->next = NULL;


Node* previousPtr = NULL;
Node* currentPtr = *sPtr;


while(currentPtr != NULL && value > currentPtr->data)
{
previousPtr = currentPtr;
currentPtr = currentPtr->next;
}


if(previousPtr == NULL)
{
newPtr->next = *sPtr;
*sPtr = newPtr;
}


else
{
previousPtr->next = newPtr;
newPtr->next = currentPtr;
}
}
else
{
printf("%c not inserted. No memory available.\n", value);
}
}


char delete (Node** sPtr, char value)
{
if(value == (*sPtr)->data)
{
Node* tempPtr = *sPtr;
*sPtr = (*sPtr)->next;
free(tempPtr);
return value;
}


else
{
Node* previousPtr = *sPtr;
Node* currentPtr = (*sPtr)->next;



while(currentPtr != NULL && currentPtr->data != value)
{
previousPtr = currentPtr;
currentPtr = currentPtr->next;
}


if(currentPtr != NULL)
{
Node* tempPtr = currentPtr;
previousPtr->next = currentPtr->next;
free(tempPtr);
return value;
}
}
return '\0';
}


int isEmpty(Node* sPtr)
{
return sPtr == NULL;
}


void printList(Node* currentPtr)
{
if(isEmpty(currentPtr))
puts("List is empty\n");
else
{
puts("The list is: ");


while(currentPtr != NULL)
{
printf("%c --> ", currentPtr->data);
currentPtr = currentPtr->next;
}
puts("NULL\n");
}
}


Ciò che non capisco più di tutti è quando viene passato l'indirizzo si startPr alla funzione che in pratica crea un puntatore sPtr a tale puntatore.. ma startPtr punta a NULL quindi di conseguenza sPtr punta a startPtr che punta a NULL. Non capisco l'utilità di questa cosa. Mi scuso se la discussione risulta troppo lunga, è la prima volta che scrivo qui e sono disperato.