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 data

↓

Check if position is 1

↓

Insert at head

↓

Traverse to position-1 node

↓

Adjust pointers: new node prev/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(Node** head, int data, int pos) {
  Node* newNode = createNode(data);
  if (pos == 1) {
    newNode->next = *head;
    if (*head) (*head)->prev = newNode;
    *head = newNode;
    return;
  }
  Node* temp = *head;
  for (int i = 1; i < pos - 1 && temp != NULL; i++) temp = temp->next;
  if (temp == NULL) return; // position out of bounds
  newNode->next = temp->next;
  if (temp->next) temp->next->prev = newNode;
  temp->next = newNode;
  newNode->prev = temp;
}

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	10 <-> 20 <-> null
2	Check if position == 1	Head=Node(10)	No pointer change	10 <-> 20 <-> null
3	Traverse to position-1 (pos=3)	Start at head (10)	temp points to 10	10 <-> 20 <-> null
4	Traverse iteration 1	temp moves to 20	temp updated	10 <-> 20 <-> null
5	Adjust newNode pointers	temp=20	newNode->next = temp->next (null), newNode->prev = temp (20)	10 <-> 20 <-> null
6	Adjust neighbors' pointers	temp=20	temp->next = newNode, newNode->next->prev = newNode (no next node)	10 <-> 20 <-> 5 <-> null
7	Insertion complete	N/A	All pointers set	10 <-> 20 <-> 5 <-> null
8	Exit	N/A	Insertion done	10 <-> 20 <-> 5 <-> null

💡 Insertion done at position 3, traversal ended after reaching position-1 node.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
head	Node(10)	Node(10)	Node(10)	Node(10)	Node(10)
temp	Node(10)	Node(10)	Node(20)	Node(20)	Node(20)
newNode	N/A	Node(5)	Node(5)	Node(5)	Node(5)

Key Moments - 3 Insights

Why do we stop traversal at position-1 instead of position?

We stop at position-1 (Step 3 and 4) because we need to insert the new node after this node. This allows us to adjust pointers correctly without losing the list structure.

What happens if the position is 1?

If position is 1 (Step 2), we insert the new node at the head by adjusting the head pointer and the previous head's prev pointer, as shown in the flow and code.

Why do we check if temp->next is NULL before adjusting its prev pointer?

Because if temp->next is NULL, it means we are inserting at the end. Trying to access temp->next->prev would cause an error. So we only update if temp->next exists (Step 6).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of temp after Step 4?

A Node with data 20

B Node with data 5

C Node with data 10

D NULL

💡 Hint

Check the 'Current Node' column at Step 4 in the execution_table.

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

A Step 3

B Step 6

C Step 5

D Step 2

💡 Hint

Look at the 'Pointer Changes' column for Step 5 in the execution_table.

If position was 1, which step would handle the insertion?

A Step 4

B Step 2

C Step 5

D Step 6

💡 Hint

Step 2 checks if position == 1 in the execution_table.

Concept Snapshot

Insert at Specific Position in Doubly Linked List:
- Create new node
- If position == 1, insert at head
- Else traverse to position-1 node
- Adjust new node's prev and next pointers
- Adjust neighbors' pointers
- Handle edge cases (empty list, end insertion)

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 it at the head by adjusting the head pointer and the previous head's prev pointer. Otherwise, traverse the list to the node just before the desired position. Then, adjust the new node's next and prev pointers to link it between the nodes. Also, update the neighboring nodes' pointers to include the new node. This process ensures the list remains connected correctly. Edge cases like inserting at the end or empty list are handled by checking pointers before updating.