Node Structure and Pointer Design in DSA Python

Mental Model

A node is a small container that holds data and a pointer to the next node, linking them like a chain.

Analogy: Imagine a treasure map where each clue points you to the next clue, forming a path to the treasure.

Node1[data|->] -> Node2[data|->] -> Node3[data|->] -> null

Dry Run Walkthrough

Input: Create a linked list with nodes holding values 1, 2, and 3 linked in order

Goal: Build a chain of nodes where each node points to the next, ending with null

Step 1: Create first node with value 1 and pointer null

Node1[1|null]

Why: Start the chain with the first node pointing to nothing

Step 2: Create second node with value 2 and pointer null

Node1[1|null]   Node2[2|null]

Why: Prepare the next node to link after the first

Step 3: Set first node's pointer to second node

Node1[1|->] -> Node2[2|null]

Why: Link first node to second to form the chain

Step 4: Create third node with value 3 and pointer null

Node1[1|->] -> Node2[2|null]   Node3[3|null]

Why: Prepare the third node to add to the chain

Step 5: Set second node's pointer to third node

Node1[1|->] -> Node2[2|->] -> Node3[3|null]

Why: Link second node to third to complete the chain

Result:

Node1[1|->] -> Node2[2|->] -> Node3[3|null]

Annotated Code

DSA Python

class Node:
    def __init__(self, data):
        self.data = data  # store the value
        self.next = None  # pointer to next node, starts as None

# Create nodes
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)

# Link nodes
node1.next = node2  # first node points to second
node2.next = node3  # second node points to third

# Function to print linked list

def print_list(head):
    current = head
    while current:
        print(current.data, end=' -> ')
        current = current.next
    print('null')

# Driver code
print_list(node1)

self.next = None # pointer to next node, starts as None

initialize pointer to null meaning no next node yet

node1.next = node2 # first node points to second

link first node to second node to form chain

node2.next = node3 # second node points to third

link second node to third node to continue chain

while current: print(current.data, end=' -> ') current = current.next

traverse nodes one by one printing data until end (null)

Output

1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(n) because printing the list visits each node once

Space: O(n) because we create n nodes each holding data and pointer

vs Alternative: Compared to arrays, linked nodes use extra space for pointers but allow easy insertion without shifting elements

Edge Cases

Empty list (no nodes)

Printing shows just 'null' because head is None

DSA Python

while current:

Single node list

Prints the single node data followed by 'null'

DSA Python

while current:

When to Use This Pattern

When you need a flexible chain of elements where each points to the next, use node and pointer design to build linked lists.

Common Mistakes

Mistake: Forgetting to set the next pointer, leaving nodes unlinked
Fix: Always assign the next pointer to link nodes explicitly

Mistake: Setting next pointer to data instead of node
Fix: Ensure next points to a node object, not just the data value

Summary

It creates small containers called nodes that hold data and a pointer to the next node.

Use it when you want to build a chain of elements that can grow or shrink easily.

The key is each node points to the next, forming a linked chain like a treasure map of clues.