Node Structure and Pointer Design in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a singly linked list after insertions

What is the printed output of the linked list after inserting nodes with values 10, 20, and 30 in that order?

DSA Python

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

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

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

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

ll = LinkedList()
ll.insert_end(10)
ll.insert_end(20)
ll.insert_end(30)
ll.print_list()

A 10 -> 20 -> 30 -> null

B 30 -> 20 -> 10 -> null

C null

D 10 -> 30 -> 20 -> null

💡 Hint

Think about how nodes are added at the end of the list.

Nodes are inserted at the end, so the order is the same as insertion: 10, then 20, then 30.

❓ Predict Output

intermediate

Output after reversing a singly linked list

What is the output of the linked list after reversing it?

DSA Python

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

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

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

    def reverse(self):
        prev = None
        current = self.head
        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node
        self.head = prev

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

ll = LinkedList()
ll.insert_end(1)
ll.insert_end(2)
ll.insert_end(3)
ll.reverse()
ll.print_list()

A 1 -> 2 -> 3 -> null

B 3 -> 2 -> 1 -> null

C null

D 1 -> 3 -> 2 -> null

💡 Hint

Reversing changes the direction of the pointers.

Reversing the list makes the last node the new head, so the order is 3, 2, 1.

🔧 Debug

advanced

Identify the error in doubly linked list node insertion

What error will occur when running this code that inserts a node at the beginning of a doubly linked list?

DSA Python

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

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

    def insert_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        if self.head:
            self.head.prev = new_node
        self.head = new_node

dll = DoublyLinkedList()
dll.insert_beginning(5)
dll.insert_beginning(10)
print(dll.head.prev.data)

A 5

B 10

C AttributeError: 'NoneType' object has no attribute 'data'

D None

💡 Hint

Check what happens to the prev pointer of the head node.

After inserting 10 at beginning, head.prev is None, so accessing head.prev.data causes AttributeError.

🧠 Conceptual

advanced

Pointer design in circular linked list

In a circular singly linked list with one node, what does the node's next pointer point to?

A It points to itself

B It points to None

C It points to a new node

D It points to the head's previous node

💡 Hint

In circular lists, the last node connects back to the first node.

With one node, its next pointer points to itself to maintain the circular structure.

❓ Predict Output

expert

Output after complex pointer manipulation in linked list

What is the output after executing the following code that manipulates pointers in a linked list?

DSA Python

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

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

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

    def manipulate(self):
        if not self.head or not self.head.next:
            return
        first = self.head
        second = first.next
        third = second.next
        # Swap first and second nodes by changing pointers
        second.next = first
        first.next = third
        self.head = second

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

ll = LinkedList()
ll.insert_end(1)
ll.insert_end(2)
ll.insert_end(3)
ll.manipulate()
ll.print_list()

A 1 -> 2 -> 3 -> null

B 1 -> 3 -> 2 -> null

C 3 -> 2 -> 1 -> null

D 2 -> 1 -> 3 -> null

💡 Hint

The manipulate method swaps the first two nodes by changing pointers.

The method swaps first and second nodes by redirecting pointers, so the list becomes 2 -> 1 -> 3 -> null.

Practice

1. What does the next pointer in a linked list node represent?

easy

A. It points to the previous node in the list

B. It stores the data value of the node

C. It points to the next node in the list

D. It stores the size of the list

Solution

1. Step 1: Understand the role of next pointer

   The next pointer in a linked list node is used to connect the current node to the following node in the sequence.

2. Step 2: Differentiate from other node parts

   The data part stores the value, and next specifically points to the next node, not previous or size.

3. Final Answer:

   It points to the next node in the list -> Option C

4. Quick Check:

   next pointer = next node address [OK]

Hint: Remember: next always leads forward in the list [OK]

Common Mistakes:

• Confusing next with data storage
• Thinking next points backward
• Assuming next stores list size

2. Which of the following is the correct way to define a simple node class in Python with a data attribute and a next pointer?

easy

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

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

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

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

Solution

1. Step 1: Check correct attribute assignment

   class Node: def __init__(self, data): self.data = data self.next = None correctly assigns self.data = data and initializes self.next = None to indicate no next node yet.

2. Step 2: Identify errors in other options

   class Node: def __init__(self, data): data = self.data next = None assigns backwards, class Node: def __init__(self): self.data = None self.next = None misses data parameter, class Node: def __init__(self, data, next): self.data = data next = None does not assign self.next properly.

3. Final Answer:

   class Node: def __init__(self, data): self.data = data self.next = None -> Option A

4. Quick Check:

   Correct attribute setup = class Node: def __init__(self, data): self.data = data self.next = None [OK]

Hint: Use self.attribute = value inside __init__ [OK]

Common Mistakes:

• Not using self to assign attributes
• Forgetting to initialize next to None
• Swapping assignment order

3. What will be the output of the following code?

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

head = Node(10)
second = Node(20)
head.next = second
print(head.next.data)

medium

A. 20

B. Error

C. None

D. 10

Solution

1. Step 1: Understand node creation and linking

   Two nodes are created: head with data 10, second with data 20. Then, head.next points to second.

2. Step 2: Trace the print statement

   head.next.data accesses the data of the node after head, which is second, so it prints 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   head.next.data = 20 [OK]

Hint: Follow the next pointer to get next node's data [OK]

Common Mistakes:

• Printing head.data instead of head.next.data
• Confusing next pointer with data
• Expecting None because of uninitialized pointer

4. Identify the error in the following code snippet for a singly linked list node:

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

node1 = Node(5)
print(node1.next)

medium

A. The class name should be lowercase

B. The data attribute is missing

C. The print statement syntax is wrong

D. The next pointer is not assigned to self

Solution

1. Step 1: Check attribute assignment in __init__

   The code assigns next = None without self., so next is a local variable, not an attribute.

2. Step 2: Understand consequence on print

   Since node1.next was never set, it raises an AttributeError or prints None if accessed differently.

3. Final Answer:

   The next pointer is not assigned to self -> Option D

4. Quick Check:

   Missing self. causes attribute error [OK]

Hint: Always use self. to create object attributes [OK]

Common Mistakes:

• Forgetting self. before next
• Assuming local variable becomes attribute
• Ignoring error from missing attribute

5. You want to create a linked list with three nodes containing values 1, 2, and 3 respectively. Which code snippet correctly links the nodes?

hard

A. n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n1.next = n3
n3.next = n2
n2.next = None

B. n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n1.next = n2
n2.next = n3
n3.next = None

C. n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n1.next = None
n2.next = n1
n3.next = n2

D. n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n3.next = n2
n2.next = n1
n1.next = None

Solution

1. Step 1: Understand correct node linking order

   To create a linked list 1 -> 2 -> 3, n1.next should point to n2, and n2.next to n3. The last node n3.next should be None.

2. Step 2: Check each option's linking

   n1 = Node(1) n2 = Node(2) n3 = Node(3) n1.next = n2 n2.next = n3 n3.next = None correctly links nodes in order. The other options link nodes in wrong order or reverse.

3. Final Answer:

   n1.next = n2; n2.next = n3; n3.next = None -> Option B

4. Quick Check:

   Correct forward linking = n1 = Node(1) n2 = Node(2) n3 = Node(3) n1.next = n2 n2.next = n3 n3.next = None [OK]

Hint: Link nodes in order, last node points to None [OK]

Common Mistakes:

• Linking nodes in reverse order
• Not setting last node's next to None
• Mixing node references