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

Concept Flow - Creating a Singly Linked List from Scratch

Start

↓

Create Node with data

↓

Is list empty?

Yes No↓

Set head to new node

↓

Set last node.next to new node

↓

Done

This flow shows how to create a new node and add it to the singly linked list, either as the first node or at the end.

Execution Sample

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)

This code creates a singly linked list and appends three nodes with data 1, 2, and 3.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create new node with data=1	0	None	null
2	List empty? Yes, set head to new node	1	head -> Node(1)	1 -> null
3	Create new node with data=2	1	None	1 -> null
4	List empty? No, traverse to last node	1	current -> Node(1)	1 -> null
5	Set last node.next to new node	2	Node(1).next -> Node(2)	1 -> 2 -> null
6	Create new node with data=3	2	None	1 -> 2 -> null
7	List empty? No, traverse to last node	2	current -> Node(1)	1 -> 2 -> null
8	Move current to next node	2	current -> Node(2)	1 -> 2 -> null
9	Set last node.next to new node	3	Node(2).next -> Node(3)	1 -> 2 -> 3 -> null
10	End of append operations	3	No pointer changes	1 -> 2 -> 3 -> null

💡 All nodes appended; list now has 3 nodes with last node.next = None

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 5	After Step 6	After Step 9	Final
head	None	None	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)
current	None	None	None	Node(1)	Node(1)	None	Node(2)	None
new_node	None	Node(1)	None	Node(2)	None	Node(3)	None	None
list size	0	0	1	1	2	2	3	3

Key Moments - 3 Insights

Why do we check if the list is empty before adding a new node?

Because if the list is empty (head is None), we must set head to the new node directly. This is shown in execution_table step 2 where head changes from None to Node(1).

Why do we traverse the list to find the last node before adding a new node?

Because in a singly linked list, we can only add a new node at the end by finding the last node whose next is None. This traversal is shown in steps 4, 7, and 8.

What does the 'next' pointer of the last node point to after appending?

It points to the new node added. For example, in step 5, Node(1).next points to Node(2), and in step 9, Node(2).next points to Node(3).

Visual Quiz - 3 Questions

Look at the execution_table, what is the visual state after step 5?

A 2 -> 1 -> null

B 1 -> null

C 1 -> 2 -> null

D null

💡 Hint

Check the 'Visual State' column in row for step 5.

At which step does the head pointer first get assigned a node?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Pointer Changes' column to see when head changes from None.

If we skip the traversal loop, what would happen when appending the second node?

A The new node would be added after the last node correctly

B The new node would become head, losing the first node

C The list would remain unchanged

D An error would occur

💡 Hint

For the second node, current is set to head (which is the last node), and since head.next is None, the loop doesn't run anyway, so skipping it adds correctly.

Concept Snapshot

Creating a singly linked list:
- Define Node with data and next pointer
- Start with head = None
- To append: create new node
- If list empty, set head to new node
- Else traverse to last node
- Set last node.next to new node
- List ends with last node.next = None

Full Transcript

We start by creating a Node class with data and next pointer. The LinkedList class has a head pointer initially None. When appending, we create a new node. If the list is empty, we set head to this new node. Otherwise, we traverse from head to find the last node (where next is None). Then we set last node's next pointer to the new node. This process is repeated for each append. The execution table shows each step, pointer changes, and the visual linked list state. The variable tracker shows how head, current, new_node, and list size change over time. Key moments clarify why we check if the list is empty and why traversal is needed. The visual quiz tests understanding of these steps. The concept snapshot summarizes the process in simple steps.