Why Linked List Exists and What Problem It Solves in DSA Python - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a linked list node with a value.

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.[1] = None

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' for a singly linked list node.

The next attribute points to the next node in the linked list.

2fill in blank

medium

Complete the code to add a new node at the beginning of the linked list.

DSA Python

def add_at_head(head, data):
    new_node = Node(data)
    new_node.[1] = head
    return new_node

Drag options to blanks, or click blank then click option'

Ahead

Bprev

Cnext

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Setting 'prev' instead of 'next' causes errors in singly linked lists.

We set the new node's next to the current head to link it properly.

3fill in blank

hard

Fix the error in the code to traverse and print all node values in the linked list.

DSA Python

def print_list(head):
    current = head
    while current is not None:
        print(current.data)
        current = current.[1]

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' or 'head' instead of 'next' causes infinite loops or errors.

To move forward through the list, update current to current.next.

4fill in blank

hard

Complete the code to add a new node at the end of the linked list.

DSA Python

def add_at_tail(head, data):
    new_node = Node(data)
    if head is None:
        return new_node
    current = head
    while current.[1] is not None:
        current = current.next
    current.[2] = new_node
    return head

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' or assuming a 'tail' pointer in a basic singly linked list.

Traverse to the last node using current.next and then link the new node with current.next = new_node.

5fill in blank

hard

Complete the code to reverse the linked list iteratively.

DSA Python

def reverse(head):
    prev = None
    curr = head
    while curr is not None:
        next_temp = curr.[1]
        curr.[2] = prev
        prev = curr
        curr = next_temp
    return prev

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' for saving next_temp or forgetting to save it causes data loss.

Save curr.next in next_temp before setting curr.next = prev to reverse the direction.

Practice

1. Why do we use a linked list instead of a simple array in some cases?

easy

A. Because linked lists are faster for accessing elements by index

B. Because linked lists use less memory than arrays always

C. Because linked lists store data in contiguous memory locations

D. Because linked lists allow easy insertion and deletion without shifting elements

Solution

1. Step 1: Understand array limitations

   Arrays store elements in contiguous memory, so inserting or deleting elements requires shifting others, which is slow.

2. Step 2: Understand linked list advantages

   Linked lists store elements in nodes linked by pointers, so insertion and deletion can be done by changing pointers without shifting.

3. Final Answer:

   Because linked lists allow easy insertion and deletion without shifting elements -> Option D

4. Quick Check:

   Linked list insertion/deletion = easy without shifting [OK]

Hint: Linked lists excel at insert/delete without moving all elements [OK]

Common Mistakes:

• Thinking linked lists use less memory always
• Believing linked lists store data contiguously
• Assuming linked lists are faster for index access

2. Which of the following is the correct way to define a node class for a singly linked list in Python?

easy

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

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

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

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

Solution

1. Step 1: Check correct attribute assignment

   The node should store data in self.data and link to next node in self.next, initialized to None.

2. Step 2: Verify constructor parameters and assignments

   class Node: def __init__(self, data): self.data = data self.next = None correctly assigns data to self.data and sets self.next to None by default.

3. Final Answer:

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

4. Quick Check:

   Node stores data and next pointer correctly = class Node: def __init__(self, data): self.data = data self.next = None [OK]

Hint: Node class: data stored, next pointer set to None initially [OK]

Common Mistakes:

• Swapping data and next assignments
• Not initializing next to None
• Missing data parameter in constructor

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

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

head = Node(1)
second = Node(2)
third = Node(3)

head.next = second
second.next = third

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

medium

A. 1 -> 2 -> 3 -> None

B. None -> 1 -> 2 -> 3

C. 1 -> 2 -> None -> 3

D. 3 -> 2 -> 1 -> None

Solution

1. Step 1: Understand linked list construction

   Nodes 1, 2, 3 are created and linked in order: head -> second -> third.

2. Step 2: Trace the while loop printing

   Loop prints current.data then moves to next node until current is None, printing 1, 2, 3 in order.

3. Final Answer:

   1 -> 2 -> 3 -> None -> Option A

4. Quick Check:

   Print linked list from head to end = 1 -> 2 -> 3 -> None [OK]

Hint: Traverse from head, print data until next is None [OK]

Common Mistakes:

• Confusing order of nodes
• Printing None at wrong place
• Not linking nodes correctly

4. The following code tries to insert a new node with value 4 after the second node in a linked list. What is the error?

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

head = Node(1)
second = Node(2)
third = Node(3)
head.next = second
second.next = third

new_node = Node(4)
second.next = new_node
new_node.next = third

medium

A. No error, code correctly inserts new_node after second

B. new_node.next should be assigned before second.next

C. new_node.next should point to second, not third

D. head.next should be updated instead of second.next

Solution

1. Step 1: Analyze insertion steps

   New node 4 is inserted after second by setting second.next to new_node, then new_node.next to third.

2. Step 2: Check pointer updates correctness

   Order of assignments is correct; new_node links to third, second links to new_node, preserving list order.

3. Final Answer:

   No error, code correctly inserts new_node after second -> Option A

4. Quick Check:

   Insertion after second node done correctly = No error, code correctly inserts new_node after second [OK]

Hint: Assign second.next to new_node, then new_node.next to third [OK]

Common Mistakes:

• Assigning pointers in wrong order
• Pointing new_node.next to second instead of third
• Updating head.next instead of second.next

5. You want to store a list of tasks where you frequently add and remove tasks from the middle. Why is a linked list better than an array here, and what problem does it solve?

hard

A. Linked list uses less memory than arrays, solving memory overflow issues

B. Linked list stores tasks in sorted order automatically, solving sorting problems

C. Linked list allows fast middle insertions/removals without shifting elements, solving array's slow shifting problem

D. Linked list allows direct access by index, solving array's slow access problem

Solution

1. Step 1: Identify array problem with middle operations

   Arrays require shifting elements when inserting or deleting in the middle, which is slow for large lists.

2. Step 2: Explain linked list advantage

   Linked lists use pointers to link nodes, so inserting or removing in the middle only changes pointers, no shifting needed.

3. Final Answer:

   Linked list allows fast middle insertions/removals without shifting elements, solving array's slow shifting problem -> Option C

4. Quick Check:

   Linked list solves slow shifting in arrays for middle insert/delete [OK]

Hint: Linked list avoids shifting by pointer changes for middle operations [OK]

Common Mistakes:

• Thinking linked lists use less memory always
• Believing linked lists sort data automatically
• Assuming linked lists allow fast index access