Linked List vs Array When to Choose Which in DSA Python - Build Both Approaches

Linked List vs Array: When to Choose Which

📖 Scenario: Imagine you are organizing a line of people waiting for a concert ticket. Sometimes people join at the end, sometimes in the middle, and sometimes you need to quickly find someone by their position in line.Two ways to organize this line are using an array or a linked list. Each has its strengths and weaknesses depending on what you want to do.

🎯 Goal: You will create a simple array and a linked list with the same people. Then you will see how adding a person in the middle works differently for each. This will help you understand when to choose an array or a linked list.

📋 What You'll Learn

Create an array (list) with 5 people names

Create a linked list with the same 5 people names

Add a new person in the middle of the array

Add a new person in the middle of the linked list

Print both data structures after insertion to compare

💡 Why This Matters

🌍 Real World

Understanding when to use arrays or linked lists helps in organizing data efficiently in software like music playlists, text editors, or social media feeds.

💼 Career

Software developers and engineers often choose the right data structure to optimize performance and resource use in applications.

1

Create an array with 5 people names

Create a list called people_array with these exact names in order: 'Alice', 'Bob', 'Charlie', 'Diana', 'Ethan'

DSA Python

# Create the list people_array with the 5 names
# Your code here

Hint

Use square brackets [] to create a list and separate names with commas.

2

Create a linked list with the same 5 people names

Define a class called Node with attributes name and next. Then create nodes for 'Alice', 'Bob', 'Charlie', 'Diana', and 'Ethan' linked in order, and assign the first node to a variable called people_linked_list

DSA Python

people_array = ['Alice', 'Bob', 'Charlie', 'Diana', 'Ethan']
# Define Node class and create linked list nodes
# Your code here

Hint

Each node stores a name and a link to the next node. Link nodes by setting node1.next = node2 and so on.

3

Add a new person in the middle of the array and linked list

Insert 'Frank' at index 2 in people_array. Then create a new Node with name 'Frank' and insert it after the node with name 'Bob' in people_linked_list

DSA Python

people_array = ['Alice', 'Bob', 'Charlie', 'Diana', 'Ethan']

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

node1 = Node('Alice')
node2 = Node('Bob')
node3 = Node('Charlie')
node4 = Node('Diana')
node5 = Node('Ethan')

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

people_linked_list = node1

# Insert 'Frank' at index 2 in people_array
# Insert 'Frank' node after 'Bob' in linked list
# Your code here

Hint

Use list.insert(index, value) for the array. For the linked list, create a new node and adjust the next links to insert it after 'Bob'.

4

Print both data structures after insertion

Print people_array. Then print the linked list names in order separated by -> and ending with null. Use variables current to traverse the linked list starting from people_linked_list.

DSA Python

people_array = ['Alice', 'Bob', 'Charlie', 'Diana', 'Ethan']

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

node1 = Node('Alice')
node2 = Node('Bob')
node3 = Node('Charlie')
node4 = Node('Diana')
node5 = Node('Ethan')

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

people_linked_list = node1

people_array.insert(2, 'Frank')

new_node = Node('Frank')
new_node.next = node2.next
node2.next = new_node

# Print people_array
# Print linked list names separated by '->' ending with 'null'
# Your code here

Hint

Use a while loop to go through the linked list nodes and build a string to print.

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