Linked List vs Array When to Choose Which in DSA Python - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an array with 5 elements.

DSA Python

arr = [[1]]

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

A1, 2, 3, 4, 5

B[]

Crange(5)

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using range(5) directly creates a range object, not a list.

Using empty brackets creates an empty list.

The array is created by listing elements separated by commas inside square brackets.

2fill in blank

medium

Complete the code to add a new node with value 10 at the start of a linked list.

DSA Python

new_node = Node(10)
new_node.next = [1]
head = new_node

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

Anew_node

Bhead

CNone

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Setting new_node.next to None breaks the list.

Using head.next instead of head causes errors.

To insert at the start, new_node.next should point to the current head.

3fill in blank

hard

Fix the error in the code to remove the last element from an array.

DSA Python

arr = [1, 2, 3, 4, 5]
arr.[1]()

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

Apop()

Bremove(5)

Cpop(0)

Ddelete()

Attempts:

3 left

💡 Hint

Common Mistakes

Using remove(5) removes the first occurrence of 5 but is less efficient.

delete() is not a valid list method.

pop() without arguments removes the last element from the list.

4fill in blank

hard

Fill both blanks to traverse a linked list and print each node's value.

DSA Python

current = head
while current [1] None:
    print(current.[2])
    current = current.next

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

Ais not

Bvalue

Cval

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of 'is not' for None check.

Using 'val' instead of 'value' if the attribute is named 'value'.

We check if current is not None to continue traversal and print the value attribute of the node.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each word to its length if length is greater than 3.

DSA Python

{ [1]: [2] for [3] in words if len([3]) > 3 }

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

Aword

Blen(word)

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inconsistently.

Not filtering words by length correctly.

The comprehension maps each word to its length for words longer than 3 characters.

Practice

1. Which data structure is better when you need fast random access to elements by index?

easy

A. Linked List

B. Array

C. Stack

D. Queue

Solution

1. Step 1: Understand random access in arrays

   Arrays store elements in contiguous memory, so accessing by index is fast and direct.

2. Step 2: Compare with linked list access

   Linked lists require traversal from the head to reach an index, which is slower.

3. Final Answer:

   Array -> Option B

4. Quick Check:

   Random access = Array [OK]

Hint: Arrays allow direct index access; linked lists do not [OK]

Common Mistakes:

• Thinking linked lists provide fast index access
• Confusing stack or queue with random access
• Assuming all data structures have same access speed

2. Which of the following is the correct way to declare an empty linked list node in Python?

easy

A. node = LinkedList()

B. node = []

C. node = None

D. node = Node()

Solution

1. Step 1: Understand linked list node creation

   A linked list node is usually an instance of a Node class, so Node() creates an empty node.

2. Step 2: Compare other options

   Empty list [] is for arrays, None is absence of value, LinkedList() is the whole list, not a node.

3. Final Answer:

   node = Node() -> Option D

4. Quick Check:

   Node creation = Node() [OK]

Hint: Use Node() to create linked list nodes, not list or None [OK]

Common Mistakes:

• Using [] which is for arrays, not nodes
• Assigning None instead of a node object
• Confusing linked list with whole list object

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

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

arr = [10, 20, 30]
linked_list = Node(10)
linked_list.next = Node(20)
linked_list.next.next = Node(30)
print(arr[1], linked_list.next.data)

medium

A. 20 20

B. 10 20

C. 20 10

D. 30 30

Solution

1. Step 1: Access array element at index 1

   arr[1] is 20 because arrays allow direct index access.

2. Step 2: Access linked list second node data

   linked_list.next points to node with data 20, so linked_list.next.data is 20.

3. Final Answer:

   20 20 -> Option A

4. Quick Check:

   arr[1] and linked_list.next.data both 20 [OK]

Hint: Array index 1 and linked list next node data match [OK]

Common Mistakes:

• Confusing linked list node data with array index
• Mixing up indices or next pointers
• Assuming linked list nodes are accessed by index

4. Find the error in this linked list insertion code snippet:

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

head = Node(1)
head.next = Node(2)
new_node = Node(3)
new_node.next = head
head = new_node
print(head.next.next.data)

medium

A. Error: new_node.next should be None

B. Error: head.next.next is None, so accessing data causes AttributeError

C. No error, output is 2

D. Error: head should not be reassigned

Solution

1. Step 1: Trace linked list after insertion

   new_node points to old head (1), so list is 3 -> 1 -> 2.

2. Step 2: Check head.next.next

   head.next is node with data 1, head.next.next is node with data 2, so head.next.next.data is 2, no error.

3. Step 3: Re-examine code print statement

   Actually, print(head.next.next.data) should print 2 without error.

4. Final Answer:

   No error, output is 2 -> Option C

5. Quick Check:

   Linked list traversal works, output 2 [OK]

Hint: Trace pointers carefully to find if None is accessed [OK]

Common Mistakes:

• Assuming head.next.next is None incorrectly
• Thinking reassignment of head is wrong
• Confusing next pointer assignments

5. You have a large dataset where you frequently insert and delete elements in the middle. Which data structure is more efficient and why?

hard

A. Linked List, because insertion and deletion in middle are faster

B. Array, because it uses less memory

C. Array, because it supports random access

D. Linked List, because it uses contiguous memory

Solution

1. Step 1: Analyze insertion and deletion in arrays

   Arrays require shifting elements after insertion/deletion, which is slow for large data.

2. Step 2: Analyze linked list operations

   Linked lists adjust pointers for insertion/deletion without shifting, making these operations faster in the middle.

3. Step 3: Compare memory usage and access

   Linked lists use more memory due to pointers and have slower random access, but faster middle updates.

4. Final Answer:

   Linked List, because insertion and deletion in middle are faster -> Option A

5. Quick Check:

   Middle insert/delete fast = Linked List [OK]

Hint: For frequent middle changes, linked list is faster [OK]

Common Mistakes:

• Choosing array for fast middle insert/delete
• Confusing memory use with operation speed
• Assuming linked list uses contiguous memory