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.