Insert at Specific Position in Doubly Linked List in DSA C# - Execution Trace

Concept Flow - Insert at Specific Position in Doubly Linked List

Create new node with value

↓

Check if position is 1

↓

Insert at head

↓

Traverse to position-1 node

↓

Adjust pointers: new node prev and next

↓

Adjust neighbors' pointers

↓

Done

Create a new node, then either insert at the head if position is 1, or traverse to the node before the target position and adjust pointers to insert the new node there.

Execution Sample

DSA C#

void InsertAtPosition(int data, int position) {
  Node newNode = new Node(data);
  if (position == 1) {
    newNode.next = head;
    if (head != null) head.prev = newNode;
    head = newNode;
    return;
  }
  Node current = head;
  for (int i = 1; i < position - 1 && current != null; i++) current = current.next;
  if (current == null) return;
  newNode.next = current.next;
  if (current.next != null) current.next.prev = newNode;
  current.next = newNode;
  newNode.prev = current;
}

This code inserts a new node with given data at the specified position in a doubly linked list.

Execution Table

Step	Operation	Current Node	Pointer Changes	Visual State
1	Create new node with data=5	N/A	newNode created	Head -> 10 <-> 20 <-> 30 <-> null
2	Check if position == 1	N/A	No change	Head -> 10 <-> 20 <-> 30 <-> null
3	Traverse to position-1 (2)	10	Move current to next	Head -> 10 <-> 20 <-> 30 <-> null
4	Traverse to position-1 (2)	20	Reached position-1 node	Head -> 10 <-> 20 <-> 30 <-> null
5	Set newNode.next = current.next	20	newNode.next -> 30	Head -> 10 <-> 20 <-> 30 <-> null
6	Set current.next.prev = newNode	20	30.prev -> newNode	Head -> 10 <-> 20 <-> 5 <-> 30 <-> null
7	Set current.next = newNode	20	20.next -> newNode	Head -> 10 <-> 20 <-> 5 <-> 30 <-> null
8	Set newNode.prev = current	20	5.prev -> 20	Head -> 10 <-> 20 <-> 5 <-> 30 <-> null
9	Insertion complete	N/A	Pointers updated	Head -> 10 <-> 20 <-> 5 <-> 30 <-> null
10	Exit	N/A	End of function	Final list: 10 <-> 20 <-> 5 <-> 30 <-> null

💡 Insertion done at position 3, all pointers updated correctly

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 7	Final
head	10	10	10	10	10
current	10	20	20	20	20
newNode	null	5 (new node)	5	5	5
newNode.next	null	null	30	30	30
newNode.prev	null	null	null	20	20

Key Moments - 3 Insights

Why do we check if position == 1 separately?

Because inserting at the head requires updating the head pointer and the previous pointer of the old head. This is shown in execution_table row 2 where we decide the insertion method.

Why do we stop traversal at position-1 node, not the position node?

We need the node before the insertion point to adjust its next pointer to the new node. This is shown in rows 3 and 4 where current moves to position-1 node.

Why do we update current.next.prev to newNode?

Because the node after the new node must point back to the new node as its previous node. This backward link update is shown in row 6.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the current node's data?

A 5

B 10

C 20

D 30

💡 Hint

Check the 'Current Node' column at step 4 in execution_table

At which step is the new node's prev pointer set?

A Step 8

B Step 5

C Step 7

D Step 6

💡 Hint

Look for 'newNode.prev' pointer changes in execution_table

If position was 1, which step would be skipped?

A Step 2

B Steps 3 to 8

C Step 1

D Step 9

💡 Hint

See concept_flow and execution_table steps for position == 1 case

Concept Snapshot

InsertAtPosition(data, pos):
- Create new node
- If pos==1, insert at head, update head and old head.prev
- Else traverse to pos-1 node
- Adjust newNode.next and newNode.prev
- Update neighbors' pointers
- Handles middle and end insertions
- Maintains doubly linked list links

Full Transcript

To insert a node at a specific position in a doubly linked list, first create the new node. If the position is 1, insert at the head by updating the head pointer and the previous pointer of the old head. Otherwise, traverse the list to the node just before the desired position. Then adjust the new node's next and prev pointers, and update the neighboring nodes to point to the new node. This keeps the list connected both forward and backward. The execution table shows each step and how pointers change, ensuring the list remains consistent after insertion.

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