Insertion Operations

Insertion is one of the most fundamental operations performed on arrays, and understanding it deeply is essential for writing efficient code and reasoning about algorithm performance. At its core, insertion means placing a new value into an array at a specific position. However, the apparent simplicity of this idea conceals a meaningful complexity: the cost of an insertion depends entirely on where in the array it takes place. Arrays in JavaScript (and in most languages) store their elements in a contiguous, ordered sequence. This means that when you insert something into the middle or the beginning of that sequence, the existing elements have to physically move to accommodate the newcomer. The more elements that must move, the more expensive the operation becomes.

To appreciate this fully, think of an array like a row of assigned seats in a theater. If you want to add a new person at the very end, you simply point them to the next empty seat — no one else moves. But if you want to add a new person at the very beginning, every single person already seated must stand up and shift one seat to the right before the new arrival can sit down. Insertion in the middle falls somewhere in between: everyone from the target seat onward must shift. This mental model maps directly onto how JavaScript arrays behave in practice, and it is the foundation for understanding the time complexity of every insertion scenario.

There are three fundamental positions where insertion can occur: at the end, at the beginning, and at an arbitrary index. Each carries a different performance profile, and choosing the right one for a given situation can be the difference between an algorithm that scales well and one that becomes painfully slow on large datasets.

Insertion at the End

Inserting at the end of an array is the simplest and most efficient form of insertion. In JavaScript, this is accomplished with the push() method. The push() method appends one or more elements to the end of an array and returns the new length of the array after the operation.

const fruits = ['apple', 'banana', 'cherry'];
fruits.push('date');
console.log(fruits); // ['apple', 'banana', 'cherry', 'date']
console.log(fruits.push('elderberry', 'fig')); // returns 6
console.log(fruits); // ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']

Notice that push() can accept multiple arguments at once, appending each one in order. The reason end insertion is so efficient is that no existing elements need to be repositioned. The JavaScript engine simply finds the next available index (which is always the current length of the array) and writes the new value there. No shifting, no iteration over existing elements — just a single write operation.

This gives end insertion a time complexity of O(1), meaning constant time. It takes the same amount of work whether the array has 5 elements or 5 million elements. This is the most performant insertion scenario available, and whenever the position of the new element is flexible or irrelevant to your algorithm, you should strongly prefer appending to the end. Many well-optimized algorithms are deliberately designed to build up their results by pushing to the end of an array rather than inserting elsewhere for exactly this reason.

Insertion at the Beginning

Inserting at the beginning of an array is a fundamentally more expensive operation. In JavaScript, this is done using the unshift() method, which inserts one or more elements at the front of the array and returns the new length.

const numbers = [10, 20, 30, 40];
numbers.unshift(5);
console.log(numbers); // [5, 10, 20, 30, 40]
console.log(numbers.unshift(1, 2, 3)); // returns 8
console.log(numbers); // [1, 2, 3, 5, 10, 20, 30, 40]

The reason unshift() is expensive becomes clear when you consider what must happen internally. Before the new element can occupy index 0, every single existing element must be moved one position to the right. The element at index 0 moves to index 1, the element at index 1 moves to index 2, and so on, all the way to the last element. Only once all existing elements have shifted can the new value be placed at the front.

This cascading shift means the work done is directly proportional to the number of elements already in the array, giving beginning insertion a time complexity of O(n), or linear time. If an array has 1,000 elements, a single unshift() triggers up to 1,000 individual reassignments. If the array has 1,000,000 elements, it triggers up to 1,000,000 reassignments. The cost grows linearly with the size of the array.

In performance-sensitive code that executes frequently or operates on large datasets, calling unshift() repeatedly inside a loop can lead to serious performance degradation. It is not that unshift() should never be used — it is simply important to use it thoughtfully and to recognize the cost it carries.

Insertion at an Arbitrary Position

The most flexible — and potentially the most nuanced — form of insertion is placing a new element at a specific index somewhere within the array. JavaScript's built-in method for this is splice(). The signature for pure insertion (without removing any elements) is:

array.splice(index, 0, newElement);

The first argument is the target index where the new element should appear. The second argument, 0, tells splice() to delete zero elements (so nothing is removed). The third argument is the new value to insert. After the call, the new element sits at the specified index, and all elements that were previously at or beyond that index have been shifted one position to the right.

const letters = ['a', 'b', 'd', 'e'];
// Insert 'c' at index 2
letters.splice(2, 0, 'c');
console.log(letters); // ['a', 'b', 'c', 'd', 'e']

You can also insert multiple elements at once:

const scores = [100, 200, 500, 600];
// Insert 300 and 400 at index 2
scores.splice(2, 0, 300, 400);
console.log(scores); // [100, 200, 300, 400, 500, 600]

The time complexity of arbitrary insertion with splice() is O(n) in the worst case. The worst case occurs when insertion happens at or near the beginning of the array, because that maximizes the number of elements that need to be shifted. Inserting at index 0 is equivalent in cost to calling unshift().

However, there is an important practical nuance: the closer the insertion point is to the end of the array, the fewer elements need to shift. If an array has 1,000 elements and you insert at index 999, only one element needs to shift. If you insert at index 500, roughly half the elements shift. This means that while the worst-case complexity is O(n), the actual runtime improves as the insertion point approaches the end. In the absolute best case — inserting at the very last position — the behavior approaches O(1). This is worth keeping in mind when reasoning about practical, real-world performance even when the theoretical worst case is O(n).

Manual Insertion Algorithm

To build genuine intuition for why arbitrary and beginning insertions are O(n), it is instructive to implement the insertion process manually, without relying on built-in methods. This exercise makes the shifting mechanism completely visible.

The algorithm works as follows: starting from the last element of the array, shift each element one index to the right, working backward toward the target index. Once the loop finishes, the target index is clear, and you assign the new value directly to it.

function insertAt(arr, index, newValue) {
  // Expand the array by one slot by incrementing length
  // (JavaScript arrays are dynamic, so we just track the new last index)
  const newLength = arr.length + 1;

  // Shift elements to the right from the end down to the target index
  for (let i = newLength - 1; i > index; i--) {
    arr[i] = arr[i - 1];
  }

  // Place the new value at the cleared target index
  arr[index] = newValue;

  return arr;
}

const data = [10, 20, 40, 50];
insertAt(data, 2, 30);
console.log(data); // [10, 20, 30, 40, 50]

Let's trace through this example step by step. The array starts as [10, 20, 40, 50] with a length of 4. We want to insert 30 at index 2. The new length will be 5.

• i = 4: arr[4] = arr[3] → arr[4] = 50. Array is now [10, 20, 40, 50, 50].
• i = 3: arr[3] = arr[2] → arr[3] = 40. Array is now [10, 20, 40, 40, 50].
• i = 2: Loop condition i > index is 2 > 2, which is false. Loop stops.
• Assignment: arr[2] = 30. Array is now [10, 20, 30, 40, 50].

The shifting loop ran twice for a 4-element array inserting at index 2. Had we inserted at index 0, the loop would have run 4 times — once for every element. This trace makes it viscerally clear why the cost scales with the number of elements that sit beyond the insertion point. Writing this algorithm by hand is one of the most effective ways to internalize why the O(n) complexity is not just a theoretical label but a direct consequence of the physical mechanics of the operation.

This understanding is also directly foundational for working with lower-level data structures such as linked lists. In a linked list, insertion at an arbitrary position does not require any shifting because elements are not stored contiguously — each node simply holds a pointer to the next. However, finding the position to insert into still requires traversal, which is its own form of O(n) cost. Understanding array insertion sharpens the lens through which you evaluate the trade-offs of linked lists and other structures.

Time and Space Complexity of Insertion

Bringing the complexity analysis together into a single clear picture is essential for applying these concepts in practice:

• End insertion (push()): O(1) time. No shifting required. The most efficient insertion operation. Use this whenever the position of the new element does not matter.
• Beginning insertion (unshift()): O(n) time. Every element in the array must shift one position to the right. The cost scales linearly with the size of the array.
• Arbitrary insertion (splice(index, 0, value)): O(n) time in the worst case. The number of shifts equals the number of elements from the target index to the end of the array. Inserting near the end is faster in practice, but worst-case remains O(n).

In terms of space complexity, all three insertion operations require O(1) additional space — they modify the existing array in place and do not allocate a new array or data structure proportional in size to the input. The array itself grows by one slot, but that growth is not additional auxiliary space; it is the direct result of the operation itself.

When an algorithm requires frequent insertions at arbitrary positions — especially near the beginning — the O(n) cost can accumulate rapidly. Inserting n elements one at a time into the front of an array results in O(n²) total work, which becomes prohibitively slow for large inputs. In these scenarios, alternative data structures like linked lists (for O(1) insertion once a position is found), deques, or skip lists may be better suited to the problem.

Choosing the right insertion strategy is not merely a micro-optimization. It is a fundamental design decision. An algorithm that carelessly inserts at the beginning inside a loop can be orders of magnitude slower than one designed to build results from the end. The ability to look at an insertion operation and immediately assess its cost — and to know when to reach for a different data structure — is a hallmark of strong algorithmic thinking.