Insert at Middle Specific Position in DSA Javascript

Mental Model

We want to add a new item exactly in the middle of a list by moving step-by-step to the right spot and linking the new item there.

Analogy: Imagine a line of people holding hands. To add a new friend in the middle, you find the person just before the middle and have them hold the new friend's hand, who then holds the next person's hand.

head -> 1 -> 2 -> 3 -> 4 -> null
                 ↑ insert here for position 3

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4 -> null, insert value 99 at position 3

Goal: Insert the value 99 at the 3rd position so the list becomes 1 -> 2 -> 99 -> 3 -> 4 -> null

Step 1: start at head node (value 1)

head -> [curr->1] -> 2 -> 3 -> 4 -> null

Why: We begin traversal from the start to find the insertion point

Step 2: move curr to node 2 (position 2)

head -> 1 -> [curr->2] -> 3 -> 4 -> null

Why: We move forward to reach the node before the insertion position

Step 3: create new node with value 99 and link it after curr

head -> 1 -> 2 -> [new->99] -> 3 -> 4 -> null

Why: Insert new node by adjusting pointers to place it at position 3

Step 4: link new node's next to node 3

head -> 1 -> 2 -> 99 -> 3 -> 4 -> null

Why: Complete insertion by connecting new node to the rest of the list

Result:

head -> 1 -> 2 -> 99 -> 3 -> 4 -> null

Annotated Code

DSA Javascript

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

class LinkedList {
  constructor() {
    this.head = null;
  }

  insertAtPosition(value, position) {
    const newNode = new Node(value);
    if (position === 1) {
      newNode.next = this.head;
      this.head = newNode;
      return;
    }
    let curr = this.head;
    let count = 1;
    while (curr !== null && count < position - 1) {
      curr = curr.next;
      count++;
    }
    if (curr === null) {
      // position is beyond list length, skip insertion
      return;
    }
    newNode.next = curr.next;
    curr.next = newNode;
  }

  printList() {
    let curr = this.head;
    let result = '';
    while (curr !== null) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const list = new LinkedList();
list.head = new Node(1);
list.head.next = new Node(2);
list.head.next.next = new Node(3);
list.head.next.next.next = new Node(4);

list.insertAtPosition(99, 3);
list.printList();

if (position === 1) { newNode.next = this.head; this.head = newNode; return; }

handle insertion at the start by linking new node before current head

while (curr !== null && count < position - 1) { curr = curr.next; count++; }

advance curr to node before insertion position

if (curr === null) { return; }

guard against position beyond list length

newNode.next = curr.next; curr.next = newNode;

insert new node by adjusting pointers

Output

1 -> 2 -> 99 -> 3 -> 4 -> null

Complexity Analysis

Time: O(n) because we may need to traverse up to n nodes to reach the insertion point

Space: O(1) because we only create one new node and use a few pointers

vs Alternative: Compared to inserting at head or tail which can be O(1), inserting in the middle requires traversal making it O(n)

Edge Cases

insert at position 1 (start of list)

new node becomes new head

DSA Javascript

if (position === 1) {

insert at position beyond list length

no insertion happens, list remains unchanged

DSA Javascript

if (curr === null) {

insert into empty list at position 1

new node becomes head

DSA Javascript

if (position === 1) {

When to Use This Pattern

When you need to add an element at a specific position inside a linked list, use the insert at position pattern by moving to the node before and linking the new node there.

Common Mistakes

Mistake: Not moving to the node before the insertion position, causing pointer errors
Fix: Traverse until position - 1 to correctly link the new node

Mistake: Not handling insertion at position 1 separately, causing head pointer errors
Fix: Add a special case for position 1 to update head pointer

Mistake: Not checking if position is beyond list length, causing runtime errors
Fix: Add a guard to return if curr becomes null before insertion

Summary

It inserts a new node at a given position inside a linked list by adjusting pointers.

Use it when you want to add an element not just at the start or end, but somewhere in the middle.

The key is to stop at the node just before the insertion point and link the new node there.

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