Insert at Specific Position in Doubly Linked List in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given data.

DSA C#

Node newNode = new Node([1]);

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

Avalue

Bdata

Citem

DnodeData

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name that is not defined in the method.

Confusing the node variable with the data variable.

The new node should be created using the variable data which holds the value to insert.

2fill in blank

medium

Complete the code to check if the position is 1 (insert at head).

DSA C#

if (position == [1]) { InsertAtHead(newNode); return; }

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

A1

B0

C-1

Dposition

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if position equals 0 instead of 1.

Using assignment operator '=' instead of comparison '=='.

Position 1 means inserting at the head of the list.

3fill in blank

hard

Fix the error in the loop that moves to the node before the insertion point.

DSA C#

for (int i = 1; i < [1] - 1; i++) { current = current.Next; }

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

Aposition

Bpos

Cindex

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using an undefined variable like pos or index.

Looping too many or too few times causing null reference.

The loop should run until the node before the desired position, so it uses position.

4fill in blank

hard

Fill both blanks to correctly link the new node between nodes.

DSA C#

newNode.Next = current.[1];
newNode.Prev = current;
current.[2] = newNode;

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

ANext

BPrev

CNextNode

DPrevious

Attempts:

3 left

💡 Hint

Common Mistakes

Using Prev instead of Next for forward links.

Mixing up the order of assignments causing broken links.

The new node's next pointer should point to current's next node, and current's next pointer should point to the new node.

5fill in blank

hard

Fill all three blanks to update the previous pointer of the next node if it exists.

DSA C#

if (newNode.[1] != null) {
    newNode.[2].[3] = newNode;
}

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

ANext

BPrev

Attempts:

3 left

💡 Hint

Common Mistakes

Using Prev instead of Next in the if condition.

Not updating the previous pointer of the next node.

If the new node's next node exists, update its previous pointer to point back to the new node.

Practice

1. What happens when you insert a new node at position 1 in a doubly linked list?

easy

A. The new node is ignored because position 1 is invalid.

B. The new node is added at the end of the list.

C. The new node becomes the new head of the list.

D. The list is reversed before insertion.

Solution

1. Step 1: Understand position 1 in doubly linked list

   Position 1 means the start of the list, so the new node should be the first element.

2. Step 2: Insert new node at head

   The new node's next pointer points to the old head, and the old head's previous pointer points back to the new node.

3. Final Answer:

   The new node becomes the new head of the list. -> Option C

4. Quick Check:

   Insert at position 1 = new head [OK]

Hint: Position 1 means new head insertion [OK]

Common Mistakes:

• Thinking position 1 means end of list
• Ignoring previous pointer update
• Assuming position 1 is invalid

2. Which of the following is the correct syntax to insert a new node at position 3 in a doubly linked list in C#?

easy

A. InsertAtPosition(newNode, 3);

B. InsertAtPosition(3, newNode);

C. InsertNodeAt(3, newNode);

D. AddNodeAtPosition(newNode, 3);

Solution

1. Step 1: Check method parameter order

   The common pattern is to pass the node first, then the position.

2. Step 2: Match method name and parameters

   InsertAtPosition(newNode, 3) matches the expected syntax for inserting at position 3.

3. Final Answer:

   InsertAtPosition(newNode, 3); -> Option A

4. Quick Check:

   Node first, position second = InsertAtPosition(newNode, 3); [OK]

Hint: Node comes before position in method call [OK]

Common Mistakes:

• Swapping parameter order
• Using incorrect method names
• Passing position before node

3. Given the doubly linked list: 10 <-> 20 <-> 30 <-> null, what is the list after inserting 15 at position 2?

medium

A. 10 <-> 15 <-> 20 <-> 30 <-> null

B. 15 <-> 10 <-> 20 <-> 30 <-> null

C. 10 <-> 20 <-> 15 <-> 30 <-> null

D. 10 <-> 20 <-> 30 <-> 15 <-> null

Solution

1. Step 1: Identify position 2 in the list

   Position 2 means after the first node (10), so new node goes between 10 and 20.

2. Step 2: Insert 15 between 10 and 20

   Update pointers: 10's next to 15, 15's previous to 10, 15's next to 20, 20's previous to 15.

3. Final Answer:

   10 <-> 15 <-> 20 <-> 30 <-> null -> Option A

4. Quick Check:

   Insert at position 2 = between first and second nodes [OK]

Hint: Position 2 means insert after first node [OK]

Common Mistakes:

• Inserting before first node
• Inserting at wrong position
• Not updating previous pointers

4. What is the error in the following code snippet for inserting at position 3 in a doubly linked list?

Node newNode = new Node(25);
Node temp = head;
for (int i = 1; i < 2; i++) {
    temp = temp.next;
}
newNode.next = temp.next;
newNode.prev = temp;
temp.next.prev = newNode;
temp.next = newNode;

medium

A. The loop should run until i < 2, not i < 3.

B. temp.next.prev = newNode; causes null reference if temp.next is null.

C. newNode.prev should be set to temp.prev instead of temp.

D. The newNode.next assignment is missing.

Solution

1. Step 1: Analyze loop and temp position

   The loop moves temp to the node at position 2, so temp.next might be null if list ends there.

2. Step 2: Check pointer updates for null safety

   Accessing temp.next.prev without checking if temp.next is null can cause a runtime error.

3. Final Answer:

   temp.next.prev = newNode; causes null reference if temp.next is null. -> Option B

4. Quick Check:

   Check for null before accessing temp.next.prev [OK]

Hint: Always check temp.next for null before accessing prev [OK]

Common Mistakes:

• Ignoring null pointer checks
• Wrong loop range causing off-by-one
• Incorrect pointer assignments

5. You have a doubly linked list: 5 <-> 10 <-> 15 <-> 20 <-> null. You want to insert a node with value 12 at position 3. After insertion, what will be the correct order of nodes?

medium

A. 5 <-> 10 <-> 15 <-> 20 <-> 12 <-> null

B. 5 <-> 12 <-> 10 <-> 15 <-> 20 <-> null

C. 12 <-> 5 <-> 10 <-> 15 <-> 20 <-> null

D. 5 <-> 10 <-> 12 <-> 15 <-> 20 <-> null

Solution

1. Step 1: Identify position 3 in the list

   Position 3 means the new node should be placed after the second node (10) and before the third node (15).

2. Step 2: Insert node with value 12 between 10 and 15

   Update pointers: 10's next to 12, 12's previous to 10, 12's next to 15, 15's previous to 12.

3. Final Answer:

   5 <-> 10 <-> 12 <-> 15 <-> 20 <-> null -> Option D

4. Quick Check:

   Insert at position 3 places node between second and third nodes [OK]

Hint: Insert at position n means between nodes n-1 and n [OK]

Common Mistakes:

• Inserting at wrong position
• Not updating both next and prev pointers
• Confusing position numbering