Why Linked List Exists and What Problem It Solves in DSA Python - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use a linked list instead of an array?

Imagine you have a list of items that can grow or shrink often. Which problem does a linked list solve better than an array?

A Linked lists allow easy insertion and deletion anywhere without shifting elements.

B Arrays use less memory than linked lists for the same number of items.

C Linked lists provide faster access to elements by index than arrays.

D Arrays can grow dynamically without any overhead.

💡 Hint

Think about what happens when you add or remove items in the middle of an array.

Arrays require shifting elements when inserting or deleting in the middle, which is slow. Linked lists just change pointers, making these operations faster.

❓ Predict Output

intermediate

Output of inserting nodes in a linked list

What is the printed linked list after inserting nodes 1, 2, 3 at the head?

DSA Python

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

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

    def insert_head(self, val):
        new_node = Node(val)
        new_node.next = self.head
        self.head = new_node

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

ll = LinkedList()
ll.insert_head(1)
ll.insert_head(2)
ll.insert_head(3)
ll.print_list()

A null -> 3 -> 2 -> 1

B 1 -> 2 -> 3 -> null

C 3 -> 2 -> 1 -> null

D 1 -> null -> 2 -> 3

💡 Hint

New nodes are added at the head, so the last inserted node appears first.

Each new node points to the previous head, so the list order reverses the insertion order at the head.

🔧 Debug

advanced

Find the bug in linked list traversal

What error does this code raise when printing the linked list?

DSA Python

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

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

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

ll = LinkedList()
ll.head = Node(1)
ll.head.next = Node(2)
ll.print_list()

A Infinite loop because current never changes

B Prints '1 -> 2 -> null' correctly

C Raises AttributeError because current becomes None

D Prints '1 -> null' missing last node

💡 Hint

Check the loop condition and what happens to the last node.

The loop stops before printing the last node because it checks current.next instead of current. So the last node's value is never printed.

🚀 Application

advanced

Why linked lists are preferred for implementing stacks?

Which reason best explains why linked lists are often used to implement stacks?

A Linked lists allow dynamic size and fast push/pop without resizing.

B Linked lists use less memory than arrays for stacks.

C Linked lists provide faster random access than arrays.

D Linked lists automatically sort elements in stack order.

💡 Hint

Think about what happens when a stack grows beyond initial size in an array.

Stacks need fast push/pop operations and dynamic size. Linked lists provide this by adding/removing nodes at the head without resizing.

❓ Predict Output

expert

Output after deleting a node in a linked list

What is the printed linked list after deleting the node with value 2?

DSA Python

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

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

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

    def delete_value(self, val):
        current = self.head
        prev = None
        while current:
            if current.val == val:
                if prev:
                    prev.next = current.next
                else:
                    self.head = current.next
                return
            prev = current
            current = current.next

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

ll = LinkedList()
ll.insert_tail(1)
ll.insert_tail(2)
ll.insert_tail(3)
ll.delete_value(2)
ll.print_list()

A 1 -> null

B 1 -> 3 -> null

C 2 -> 3 -> null

D 1 -> 2 -> 3 -> null

💡 Hint

Check how the delete_value method updates pointers when deleting the node.

The node with value 2 is removed by linking the previous node (1) to the next node (3), so the list becomes 1 -> 3 -> null.