Insert at Middle Specific Position in DSA Javascript - Execution Trace

Concept Flow - Insert at Middle Specific Position

Start with Linked List

↓

Check if position is valid

Yes↓

Traverse to node before position

↓

Create new node

↓

Adjust pointers to insert node

↓

Insertion complete

↓

End

The flow starts by checking the position, then moves to the node before the target, inserts the new node by adjusting pointers, and ends.

Execution Sample

DSA Javascript

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

function insertAtPosition(head, data, position) {
  if (position === 0) {
    let newNode = new Node(data);
    newNode.next = head;
    return newNode;
  }
  let current = head;
  let count = 0;
  while (current !== null && count < position - 1) {
    current = current.next;
    count++;
  }
  if (current === null) return head;
  let newNode = new Node(data);
  newNode.next = current.next;
  current.next = newNode;
  return head;
}

This code inserts a new node with given data at a specific position in a singly linked list.

Execution Table

Step	Action	Current Node Data	Count	Position	Pointers Changed	List State
1	Start with head node	1	0	2	None	1 -> 2 -> 4 -> null
2	Check position != 0	-	-	2	None	1 -> 2 -> 4 -> null
3	Traverse to node before position	1	0	2	None	1 -> 2 -> 4 -> null
4	Traverse next node	2	1	2	None	1 -> 2 -> 4 -> null
5	Stop traversal (count=1, position-1=1)	2	1	2	None	1 -> 2 -> 4 -> null
6	Create new node with data=3	-	-	-	None	1 -> 2 -> 4 -> null
7	Set newNode.next = current.next (4)	2	1	2	newNode.next = 4	1 -> 2 -> 4 -> null
8	Set current.next = newNode	2	1	2	2.next = 3	1 -> 2 -> 3 -> 4 -> null
9	Insertion complete	-	-	-	None	1 -> 2 -> 3 -> 4 -> null

💡 Traversal stops when count reaches position-1; insertion done by pointer adjustments.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 7	After Step 8	Final
current.data	1	1	2	2	2	2	2
count	0	0	1	1	1	1	1
newNode.data	undefined	undefined	undefined	undefined	3	3	3
newNode.next	undefined	undefined	undefined	undefined	4	4	4
head	1	1	1	1	1	1	1

Key Moments - 3 Insights

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

We stop at position - 1 because we need to insert the new node after the current node, so we must reach the node just before the target position. See execution_table step 5.

What happens if the position is 0?

If position is 0, the new node becomes the new head, pointing to the old head. This is handled separately before traversal. See code in execution_sample lines 6-9.

Why do we set newNode.next = current.next before current.next = newNode?

Setting newNode.next first preserves the link to the rest of the list, so we don't lose nodes. Then current.next points to newNode, inserting it properly. See execution_table steps 7 and 8.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of 'current.data'?

A 1

B 3

C 2

D 4

💡 Hint

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

At which step does the new node get linked into the list?

A Step 7

B Step 8

C Step 6

D Step 9

💡 Hint

Look for when 'current.next' is set to 'newNode' in execution_table.

If position was 0, what would be the new head's data after insertion?

A Data of new node

B Data of old head

C Null

D Data of node at position 1

💡 Hint

Refer to execution_sample code lines handling position 0 insertion.

Concept Snapshot

Insert at Middle Specific Position in Linked List:
- Traverse to node before target position (position-1).
- Create new node.
- Set newNode.next = current.next.
- Set current.next = newNode.
- If position is 0, new node becomes new head.
- Adjust pointers carefully to avoid losing nodes.

Full Transcript

This visual execution shows how to insert a new node at a specific middle position in a singly linked list. We start by checking if the position is zero, which means inserting at the head. Otherwise, we traverse the list until we reach the node just before the target position. Then we create a new node, link its next pointer to the next node of the current node, and finally update the current node's next pointer to the new node. This careful pointer adjustment inserts the new node without losing any part of the list. The execution table tracks each step, showing the current node, count, and list state. The variable tracker shows how variables change after each step. Key moments clarify common confusions like why we stop traversal at position-1 and the order of pointer changes. The quiz tests understanding of these steps and pointer updates.

Practice

1. What does inserting at a specific middle position in a linked list mean?

easy

A. Removing a node from the middle of the list

B. Adding a new node only at the start of the list

C. Adding a new node exactly at the given position counting from the start

D. Adding a new node only at the end of the list

Solution

1. Step 1: Understand insertion position

   Inserting at a specific middle position means placing the new node exactly at that index, shifting others if needed.

2. Step 2: Differentiate from other operations

   Insertion at start or end is different; here we insert inside the list at the given position.

3. Final Answer:

   Adding a new node exactly at the given position counting from the start -> Option C

4. Quick Check:

   Insert at position = Add node there [OK]

Hint: Insert means add new node at exact position [OK]

Common Mistakes:

• Confusing insertion with deletion
• Thinking insertion only happens at start or end
• Ignoring position counting from start

2. Which of the following is the correct syntax to insert a node at position 3 in a singly linked list in JavaScript?

easy

A. list.insert(newNode, 3);

B. list.addNode(3, newNode);

C. list.pushAt(3, newNode);

D. list.insertAt(3, newNode);

Solution

1. Step 1: Identify common method naming

   Common method to insert at a position is named insertAt(position, node).

2. Step 2: Match parameters order

   Position comes first, then the node to insert, matching list.insertAt(3, newNode).

3. Final Answer:

   list.insertAt(3, newNode); -> Option D

4. Quick Check:

   insertAt(position, node) syntax [OK]

Hint: insertAt(position, node) is standard [OK]

Common Mistakes:

• Swapping parameter order
• Using wrong method names
• Confusing insertAt with push or addNode

3. What will be the linked list after inserting value 99 at position 2 in the list: 10 -> 20 -> 30 -> null?

function insertAtPosition(head, value, position) {
  let newNode = { value: value, next: null };
  if (position === 1) {
    newNode.next = head;
    return newNode;
  }
  let current = head;
  let count = 1;
  while (count < position - 1 && current != null) {
    current = current.next;
    count++;
  }
  if (current == null) return head;
  newNode.next = current.next;
  current.next = newNode;
  return head;
}

let head = { value: 10, next: { value: 20, next: { value: 30, next: null } } };
head = insertAtPosition(head, 99, 2);

// Print list
let result = [];
let temp = head;
while(temp) {
  result.push(temp.value);
  temp = temp.next;
}
console.log(result);

medium

A. [99, 10, 20, 30]

B. [10, 99, 20, 30]

C. [10, 20, 99, 30]

D. [10, 20, 30, 99]

Solution

1. Step 1: Locate position 2 in the list

   Position 2 means after first node (10), before second node (20).

2. Step 2: Insert new node with value 99 at position 2

   New node points to 20, first node points to new node, resulting list: 10 -> 99 -> 20 -> 30.

3. Final Answer:

   [10, 99, 20, 30] -> Option B

4. Quick Check:

   Insert 99 at pos 2 shifts 20 right [OK]

Hint: Insert shifts nodes right at position [OK]

Common Mistakes:

• Inserting at wrong position
• Not updating next pointers correctly
• Confusing position counting starting at 0

4. The following code tries to insert a node at position 4 in a list with 3 nodes. What is the error?

function insertAtPosition(head, value, position) {
  let newNode = { value: value, next: null };
  if (position === 1) {
    newNode.next = head;
    return newNode;
  }
  let current = head;
  let count = 1;
  while (count < position - 1) {
    current = current.next;
    count++;
  }
  newNode.next = current.next;
  current.next = newNode;
  return head;
}

medium

A. The while loop can cause an error if position is greater than list length + 1

B. The newNode is not created properly

C. The function does not return the head

D. The position check for 1 is incorrect

Solution

1. Step 1: Analyze while loop condition

   The loop runs without checking if current is null, so if position > list length + 1, current becomes null and next access fails.

2. Step 2: Identify missing boundary check

   There is no check to stop loop if current is null, causing runtime error when accessing current.next.

3. Final Answer:

   The while loop can cause an error if position is greater than list length + 1 -> Option A

4. Quick Check:

   Loop needs null check to avoid error [OK]

Hint: Always check current != null in loops [OK]

Common Mistakes:

• Ignoring null checks in loops
• Assuming position is always valid
• Not returning head after insertion

5. You have a singly linked list representing a queue: 5 -> 10 -> 15 -> 20 -> null. You want to insert a new value 12 exactly in the middle position (between 10 and 15). Which code snippet correctly inserts 12 at position 3?

function insertAtPosition(head, value, position) {
  let newNode = { value: value, next: null };
  if (position === 1) {
    newNode.next = head;
    return newNode;
  }
  let current = head;
  let count = 1;
  while (count < position - 1 && current != null) {
    current = current.next;
    count++;
  }
  if (current == null) return head;
  newNode.next = current.next;
  current.next = newNode;
  return head;
}

let head = { value: 5, next: { value: 10, next: { value: 15, next: { value: 20, next: null } } } };
head = insertAtPosition(head, 12, 3);

// Print list
let result = [];
let temp = head;
while(temp) {
  result.push(temp.value);
  temp = temp.next;
}
console.log(result);

What is the output?

hard

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

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

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

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

Solution

1. Step 1: Identify position 3 in the list

   Position 3 means after nodes 5 (pos 1) and 10 (pos 2), so between 10 and 15.

2. Step 2: Insert new node with value 12 at position 3

   New node points to 15, node 10 points to new node, resulting list: 5 -> 10 -> 12 -> 15 -> 20.

3. Final Answer:

   [5, 10, 12, 15, 20] -> Option A

4. Quick Check:

   Insert 12 at pos 3 shifts 15 right [OK]

Hint: Insert at position shifts next nodes right [OK]

Common Mistakes:

• Inserting at wrong position
• Not updating next pointers correctly
• Confusing position indexing starting at 0