Bird
Raised Fist0
DSA Javascriptprogramming~5 mins

Insert at Middle Specific Position in DSA Javascript - Time & Space Complexity

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Time Complexity: Insert at Middle Specific Position
O(n)
Understanding Time Complexity

When inserting an element at a specific middle position in a list, it is important to understand how the time taken changes as the list grows.

We want to know how the number of steps grows when the list gets bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.


function insertAtMiddle(arr, element, position) {
  for (let i = arr.length; i > position; i--) {
    arr[i] = arr[i - 1];
  }
  arr[position] = element;
  return arr;
}

This code inserts an element into an array at a given middle position by shifting elements to the right.

Identify Repeating Operations
  • Primary operation: The for-loop that shifts elements one position to the right.
  • How many times: It runs from the end of the array down to the insertion position, so roughly n - position times.
How Execution Grows With Input

As the array size grows, the number of shifts grows roughly in proportion to how far the insertion point is from the end.

Input Size (n)Approx. Operations (shifts)
10About 5 if inserting in middle
100About 50 if inserting in middle
1000About 500 if inserting in middle

Pattern observation: The number of operations grows roughly linearly with the size of the array.

Final Time Complexity

Time Complexity: O(n)

This means the time to insert grows in a straight line as the array gets bigger.

Common Mistake

[X] Wrong: "Inserting in the middle is always very fast because we just put the element there."

[OK] Correct: Actually, we must move all elements after the insertion point to make space, which takes time proportional to how many elements are shifted.

Interview Connect

Understanding how insertion time grows helps you explain and reason about array operations clearly, a useful skill in many coding discussions.

Self-Check

"What if we changed the data structure from an array to a linked list? How would the time complexity for insertion at a middle position change?"

Practice

(1/5)
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
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard