Insert at Middle Specific Position in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting at position 3?

Consider a singly linked list with nodes containing values 10 -> 20 -> 30 -> 40 -> null. We insert a new node with value 25 at position 3 (1-based index). What is the resulting list?

DSA Python

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

def insert_at_position(head, data, pos):
    new_node = Node(data)
    if pos == 1:
        new_node.next = head
        return new_node
    current = head
    count = 1
    while current and count < pos - 1:
        current = current.next
        count += 1
    if not current:
        return head
    new_node.next = current.next
    current.next = new_node
    return head

def print_list(head):
    result = []
    current = head
    while current:
        result.append(current.data)
        current = current.next
    return result

head = Node(10)
head.next = Node(20)
head.next.next = Node(30)
head.next.next.next = Node(40)

head = insert_at_position(head, 25, 3)
print(print_list(head))

A [25, 10, 20, 30, 40]

B [10, 20, 25, 30, 40]

C [10, 25, 20, 30, 40]

D [10, 20, 30, 40, 25]

💡 Hint

Remember that position 3 means the new node should be the third node in the list.

The new node with value 25 is inserted after the second node (20), so it becomes the third node. The list updates to 10 -> 20 -> 25 -> 30 -> 40 -> null.

❓ Predict Output

intermediate

What is the output after inserting at position 1?

Given a linked list 5 -> 15 -> 25 -> null, insert a node with value 1 at position 1. What is the resulting list?

DSA Python

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

def insert_at_position(head, data, pos):
    new_node = Node(data)
    if pos == 1:
        new_node.next = head
        return new_node
    current = head
    count = 1
    while current and count < pos - 1:
        current = current.next
        count += 1
    if not current:
        return head
    new_node.next = current.next
    current.next = new_node
    return head

def print_list(head):
    result = []
    current = head
    while current:
        result.append(current.data)
        current = current.next
    return result

head = Node(5)
head.next = Node(15)
head.next.next = Node(25)

head = insert_at_position(head, 1, 1)
print(print_list(head))

A [1, 5, 15, 25]

B [5, 1, 15, 25]

C [5, 15, 25, 1]

D [1, 15, 25]

💡 Hint

Inserting at position 1 means the new node becomes the new head.

The new node with value 1 is inserted at the start, so it points to the old head (5). The list becomes 1 -> 5 -> 15 -> 25 -> null.

🔧 Debug

advanced

Why does this insertion code fail to insert at position 4?

The code below tries to insert a node with value 50 at position 4 in the list 10 -> 20 -> 30 -> null, but the list remains unchanged. What is the bug?

DSA Python

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

def insert_at_position(head, data, pos):
    new_node = Node(data)
    current = head
    count = 1
    while current and count < pos:
        current = current.next
        count += 1
    if not current:
        return head
    new_node.next = current.next
    current.next = new_node
    return head

head = Node(10)
head.next = Node(20)
head.next.next = Node(30)

head = insert_at_position(head, 50, 4)

# Print list
result = []
cur = head
while cur:
    result.append(cur.data)
    cur = cur.next
print(result)

A The loop condition should be count < pos - 1 to stop at the node before insertion point.

B The position variable is off by one; it should start counting from zero.

C The function should check if head is None before insertion.

D The new node's next should be set to None explicitly before insertion.

💡 Hint

Think about where the pointer 'current' stops before insertion.

The loop moves current to the node at position 4, but insertion requires stopping at position 3 to link the new node. Changing the loop to count < pos - 1 fixes this.

❓ Predict Output

advanced

What is the output after inserting at position beyond list length?

Given a linked list 1 -> 2 -> 3 -> null, what is the output after trying to insert 99 at position 5?

DSA Python

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

def insert_at_position(head, data, pos):
    new_node = Node(data)
    if pos == 1:
        new_node.next = head
        return new_node
    current = head
    count = 1
    while current and count < pos - 1:
        current = current.next
        count += 1
    if not current:
        return head
    new_node.next = current.next
    current.next = new_node
    return head

def print_list(head):
    result = []
    current = head
    while current:
        result.append(current.data)
        current = current.next
    return result

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

head = insert_at_position(head, 99, 5)
print(print_list(head))

A [99, 1, 2, 3]

B [1, 2, 3, 99]

C [1, 2, 3]

D IndexError

💡 Hint

If the position is beyond the list length, the list remains unchanged.

The function returns the original list because position 5 is beyond the current list length of 3, so no insertion happens.

🧠 Conceptual

expert

What is the time complexity of inserting at a specific middle position in a singly linked list?

Assuming a singly linked list with n nodes, what is the time complexity to insert a new node at position k (1 <= k <= n+1)?

A O(log n) because linked lists use binary search to find positions.

B O(1) because insertion is always constant time in linked lists.

C O(n) because we always traverse the entire list regardless of position.

D O(k) because we must traverse to the (k-1)th node before insertion.

💡 Hint

Think about how many nodes you must visit before inserting.

To insert at position k, you must move through k-1 nodes to reach the insertion point, so the time is proportional to k, which is O(k).

Practice

1. What does it mean to insert an element at a specific middle position in a list?

easy

A. Add the element exactly at the given index, shifting others right

B. Replace the element at the given index with the new element

C. Add the element only if the list is empty

D. Add the element at the end of the list regardless of position

Solution

1. Step 1: Understand list insertion

   Inserting at a specific position means placing the new element at that index and moving existing elements to the right.

2. Step 2: Differentiate from replacement

   Replacing overwrites the element, but insertion shifts elements to keep all.

3. Final Answer:

   Add the element exactly at the given index, shifting others right -> Option A

4. Quick Check:

   Insert means add and shift, not replace or append [OK]

Hint: Insert shifts elements right at the given index [OK]

Common Mistakes:

• Confusing insert with replace
• Thinking insert always adds at end
• Assuming insert only works on empty lists

2. Which of the following is the correct syntax to insert the value 10 at index 2 in a Python list named lst?

easy

A. lst.append(2, 10)

B. lst.insert(2, 10)

C. lst.add(2, 10)

D. lst[2] = 10

Solution

1. Step 1: Recall Python list insertion method

   Python lists use the insert(index, value) method to add an element at a specific position.

2. Step 2: Check other options

   add is not a list method, append adds only at the end, and lst[2] = 10 replaces the element at index 2.

3. Final Answer:

   lst.insert(2, 10) -> Option B

4. Quick Check:

   Use insert(index, value) to add at position [OK]

Hint: Use insert(index, value) to add at any position [OK]

Common Mistakes:

• Using append to insert in middle
• Trying to assign with lst[2] = 10 instead of insert
• Using non-existent add method

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

lst = [1, 2, 4, 5]
lst.insert(2, 3)
print(lst)

medium

A. [1, 2, 3, 4, 5]

B. [1, 2, 4, 3, 5]

C. [3, 1, 2, 4, 5]

D. [1, 2, 4, 5, 3]

Solution

1. Step 1: Understand insert at index 2

   Index 2 means the third position (0-based). Inserting 3 here shifts 4 and 5 right.

2. Step 2: Visualize the list after insertion

   List becomes [1, 2, 3, 4, 5] after insertion.

3. Final Answer:

   [1, 2, 3, 4, 5] -> Option A

4. Quick Check:

   Insert at index 2 places 3 before 4 [OK]

Hint: Index 2 means third position, insert shifts right [OK]

Common Mistakes:

• Inserting after index instead of at index
• Confusing insert with replace
• Miscounting zero-based index

4. Find the error in the following code that tries to insert 99 at index 3:

lst = [10, 20, 30]
lst.insert(4, 99)
print(lst)

medium

A. Index 4 is out of range, causes error

B. insert method requires two arguments

C. No error; 99 is added at the end

D. lst should be converted to a set before insert

Solution

1. Step 1: Check index validity for insert

   Python's insert allows index beyond list length; it adds element at the end.

2. Step 2: Confirm behavior of insert with large index

   Since index 4 > length 3, 99 is appended at the end without error.

3. Final Answer:

   No error; 99 is added at the end -> Option C

4. Quick Check:

   Insert with large index appends at end [OK]

Hint: Insert with index > length appends at end [OK]

Common Mistakes:

• Assuming index out of range causes error
• Confusing insert with assignment
• Thinking list must be converted to set

5. Given a list lst = [5, 10, 15, 20, 25], write code to insert the value 12 exactly in the middle of the list. What will be the list after insertion?

hard

A. [5, 10, 15, 12, 20, 25]

B. [12, 5, 10, 15, 20, 25]

C. [5, 12, 10, 15, 20, 25]

D. [5, 10, 12, 15, 20, 25]

Solution

1. Step 1: Calculate middle index of the list

   List length is 5, middle index is length // 2 = 2.

2. Step 2: Insert 12 at index 2

   Using lst.insert(2, 12) places 12 between 10 and 15.

3. Final Answer:

   [5, 10, 12, 15, 20, 25] -> Option D

4. Quick Check:

   Middle index = 2, insert shifts elements right [OK]

Hint: Middle index = length // 2, insert there [OK]

Common Mistakes:

• Inserting at wrong index (like 3)
• Replacing element instead of inserting
• Not calculating middle index correctly