Adding to the front of a Linked List in C - c

Question

I'm having trouble comprehending linked lists in general. I understand how they work on paper, but once I get to coding them, I never seem to accomplish anything.
Here's my code:
header file:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
typedef struct List {
int data;
struct List * next;
} List;
implementation file:
#include "test.h"
void addToFront(int data, List * head);
int main(void) {
List * list;
list = malloc(sizeof(List));
list->next = NULL;
List * head;
head = NULL;
addToFront(5,head);
printf("%d",head->data); //print first element
printf("%d",list->data); //print first element
}
void addToFront(int data, List * head) {
if(head == NULL) {
List * newNode = malloc(sizeof(List));
newNode->data = data;
head = newNode;
}
else {
List * newNode = malloc(sizeof(List));
newNode->data = data;
newNode->next = head;
head = newNode;
}
}
I know that for a linked list to be empty, the header is NULL, so I have that checked there. The issue arises as I get a segfault saying that the header is not initialized, well obviously it's not, if I do initializes, I can't keep track of if the list is empty or not, hence the use of a header node.
What can I do now? I don't want to use double pointers, as for my class no one else is using them at any point so far yet (Please don't make me use double pointers), and I'm completely lost on how to proceed here.
I was thinking of trying this without a header node. As such I could have a counter that keeps track of the items in the list, check if its zero and then just add the basic element to the front, otherwise do the same thing I'm doing in my else statement?

Answer 1

The problem is in your addFront function, you only pass the pointer to the head, in order to change what the head points to you need to pass the address of the head:
void addToFront(int data, List ** head)
then
*head = newHead
When you pass only the pointer you are just passing a copy of the pointer to the function so any changes to the pointer you do inside the function are lost once you leave the function scope.
Similar in concept to:
void f(int n)
{
n = 53;
}
To avoid double pointer you can return the new head:
List* addToFront(int data, List* head)
{
...
return newNode;
}
...
head = addToFront(data, head);
...

Answer 2

If you don't want to use double pointer, you can use the header node as a sentinel node, which act solely as a placeholder, so that the first element is linked by head->next, and to check if the list is empty, check head->next == NULL. Try this:
int main(void) {
List *head = malloc(sizeof(List));
head->data = 0;
head->next = NULL;
addToFront(5, head);
List *first = head->next;
if (first) { // safe guard for first element
printf("%d", first->data); //print first element
printf("%d", first->data); //print first element
}
}
void addToFront(int data, List * head) {
List * newNode = malloc(sizeof(List));
newNode->data = data;
newNode->next = head->next;
head->next = newNode;
}