Sentinel Node in a C Linked List

I'm trying to learn more about linked lists in C and I recently stumbled upon the Sentinel Node concept, but I can't wrap my head around it. According to the slides I have, the sentinel node should be the first thing on the list when it's created and the last when other nodes are added. There should be a pointer to permanently point to the Sentinel Node. All those stuff confuse me and I would love some help with the implementation.

/*this is a simple LL implementation*/
#include <stdio.h>
#include <stdlib.h>

struct List
{
    int data;
    struct List *next;
};

void ListInsert(int new_data)
{
    struct List *p;
    p = (struct List *)malloc(sizeof(struct List));
    p->data = new_data;
    p->next = (head);
    head = p;
}

void printList(struct List *q)
{
    q = head;
    while (q != NULL)
    {
        printf("%d ", q->data);
        q = q->next;
    }
    printf("\n");
}

int main()
{
    ListInsert(5);
    ListInsert(7);
    ListInsert(6);
    ListInsert(4);
    ListInsert(2);
    printList(head);
    return 0;
}

Now, if I want to create the sentinel node, how should I proceed?

According to the slides i have, the sentinel node should be the first thing on the list when its created and the last when other nodes are added.There should be a pointer to permanently point to the Sentinel Node.

Let's start with the most important point: the purpose of a sentinel node, which is to mark the end of the list. There will not be real data associated with a sentinel node, so a list containing only a sentinel node is logically empty.

A few things follow from that, including:

• the identity of the sentinel node is a property of the whole list, not of any (other) particular node
• list manipulation algorithms need to be written differently for linked lists whose ends are marked by a sentinel than for those whose ends are marked by some other means.
• each list need a place to store the sentinel's identity
• a list that is expected to have a sentinel is invalid if it does not have one

There are many ways to implement the details, all with their own advantages and disadvantages.

Personally, I would be inclined (in the non-sentinel case, too) to have a structure to represent an overall list, separate from the structure used to represent a list node. A pointer to the list's head node would be a member of this structure, and in the sentinel-terminated-list case, so would be a pointer to the sentinel node. When you create a new list, you create a sentinel node for it, too; initially, the list's head and sentinel pointers will both point to that node. The head pointer may be changed, but the sentinel pointer must not be. When you append to the list, the appended node gets placed just before the sentinel. It is an error to try to delete the sentinel from the list.

It is to your advantage to write the code for this yourself.