Creating a Singly Linked List from Scratch in DSA C - Visual Walkthrough

Concept Flow - Creating a Singly Linked List from Scratch

Start

↓

Create head node with data

↓

Set head.next = NULL

↓

For each new data item

↓

Create new node

↓

Traverse list to last node

↓

Set last_node.next = new_node

↓

Set new_node.next = NULL

↓

Repeat or End

We start by creating the first node as head. For each new item, we create a node, find the last node, and link the new node at the end.

Execution Sample

DSA C

#include <stdlib.h>

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

struct Node *head;

// Create head node
head = (struct Node*)malloc(sizeof(struct Node));
head->data = 10;
head->next = NULL;

This code creates the first node of the singly linked list with data 10 and sets its next pointer to NULL.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create head node with data=10	10	head -> Node(10)	10 -> NULL
2	Create new node with data=20	10, 20	new_node -> Node(20)	10 -> NULL, 20 -> NULL
3	Traverse to last node (10)	10, 20	current -> Node(10)	10 -> NULL, 20 -> NULL
4	Link last node next to new_node	10, 20	10.next -> 20	10 -> 20 -> NULL
5	Create new node with data=30	10, 20, 30	new_node -> Node(30)	10 -> 20 -> NULL, 30 -> NULL
6	Traverse to last node (20)	10, 20, 30	current -> Node(20)	10 -> 20 -> NULL, 30 -> NULL
7	Link last node next to new_node	10, 20, 30	20.next -> 30	10 -> 20 -> 30 -> NULL
8	End of insertions	10, 20, 30	No pointer changes	10 -> 20 -> 30 -> NULL

💡 All nodes inserted; last node's next pointer is NULL indicating end of list.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	After Step 5	After Step 7	Final
head	NULL	Node(10)	Node(10)	Node(10)	Node(10)	Node(10)	Node(10)
new_node	NULL	NULL	Node(20)	Node(20)	Node(30)	Node(30)	NULL
current	NULL	NULL	NULL	Node(10)	Node(10)	Node(20)	NULL
List Size	0	1	1	2	2	3	3

Key Moments - 3 Insights

Why do we set the new node's next pointer to NULL?

Because the new node is the last node in the list, its next pointer must be NULL to mark the end. See steps 1, 2, 5 in execution_table where new nodes are created with next = NULL.

Why do we traverse to the last node before linking the new node?

We must find the current last node to link its next pointer to the new node. This is shown in steps 3 and 6 where current points to the last node before linking.

What happens if the list is empty when inserting the first node?

If the list is empty, head is NULL. We create the first node and assign it to head, as in step 1. No traversal is needed.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the visual state of the list?

A 10 -> 20 -> NULL

B 10 -> NULL, 20 -> NULL

C 20 -> 10 -> NULL

D 10 -> 20 -> 30 -> NULL

💡 Hint

Check the Visual State column at step 4 in execution_table.

At which step does the list size become 3 according to variable_tracker?

A After Step 4

B After Step 5

C After Step 7

D After Step 2

💡 Hint

Look at the List Size row in variable_tracker and find when it reaches 3.

If we forget to set new_node->next = NULL when creating a new node, what will happen to the list?

A The list will end correctly with NULL.

B The list may have a cycle or undefined end.

C The head pointer will be lost.

D The new node will not be linked.

💡 Hint

Think about the importance of NULL in marking the end of the list as shown in key_moments.

Concept Snapshot

Creating a Singly Linked List:
- Define Node with data and next pointer
- Create head node with data and next = NULL
- For each new data:
  - Create new node with next = NULL
  - Traverse to last node
  - Link last node's next to new node
- Last node's next always NULL to mark list end

Full Transcript

To create a singly linked list from scratch, start by defining a node structure with data and a next pointer. Create the head node with the first data value and set its next pointer to NULL, indicating the end of the list. For each new data item, create a new node with next set to NULL. Then, traverse the list from head to find the last node whose next pointer is NULL. Link this last node's next pointer to the new node. Repeat this process for all new data items. The last node's next pointer always remains NULL to mark the end of the list. This process ensures a chain of nodes connected by next pointers, forming the singly linked list.