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.