Array Insertion at Beginning in DSA Python

Mental Model

To insert a new item at the start of an array, we shift all existing items one step to the right to make space.

Analogy: Imagine a row of chairs where you want to add a new person at the front. Everyone must stand up and move one chair back to free the first chair.

Index: 0   1   2   3   4
Array: [1]->[2]->[3]->[4]->null

Dry Run Walkthrough

Input: array: [1, 2, 3, 4], insert value 0 at beginning

Goal: Add 0 at the start so the array becomes [0, 1, 2, 3, 4]

Step 1: Shift element at index 3 (4) to index 4

[1]->[2]->[3]->[4]->[4]

Why: Make space at the start by moving last element one step right

Step 2: Shift element at index 2 (3) to index 3

[1]->[2]->[3]->[3]->[4]

Why: Continue shifting elements right to free index 0

Step 3: Shift element at index 1 (2) to index 2

[1]->[2]->[2]->[3]->[4]

Why: Keep shifting elements right

Step 4: Shift element at index 0 (1) to index 1

[1]->[1]->[2]->[3]->[4]

Why: Last shift to free index 0

Step 5: Insert new value 0 at index 0

[0]->[1]->[2]->[3]->[4]

Why: Place the new value at the beginning

Result:

Final array: [0]->[1]->[2]->[3]->[4]

Annotated Code

DSA Python

class Array:
    def __init__(self, capacity):
        self.capacity = capacity
        self.size = 0
        self.data = [None] * capacity

    def insert_at_beginning(self, value):
        if self.size == self.capacity:
            raise Exception("Array is full")
        # Shift elements right to make space at index 0
        for i in range(self.size - 1, -1, -1):
            self.data[i + 1] = self.data[i]
        self.data[0] = value
        self.size += 1

    def __str__(self):
        return ' -> '.join(str(self.data[i]) for i in range(self.size)) + ' -> null'

# Driver code
arr = Array(10)
arr.data[0] = 1
arr.data[1] = 2
arr.data[2] = 3
arr.data[3] = 4
arr.size = 4

arr.insert_at_beginning(0)
print(arr)

for i in range(self.size - 1, -1, -1):

Shift elements right starting from the last to avoid overwriting

self.data[i + 1] = self.data[i]

Move element at i to i+1 to create space at index 0

self.data[0] = value

Insert new value at the beginning

self.size += 1

Increase size after insertion

Output

0 -> 1 -> 2 -> 3 -> 4 -> null

Complexity Analysis

Time: O(n) because we must shift all existing elements one position to the right

Space: O(1) since insertion is done in place without extra storage

vs Alternative: Compared to appending at the end which is O(1), insertion at beginning is slower due to shifting

Edge Cases

Empty array

Inserts value at index 0 without shifting

DSA Python

if self.size == self.capacity: raise Exception("Array is full")

Array at full capacity

Raises exception to prevent overflow

DSA Python

if self.size == self.capacity: raise Exception("Array is full")

When to Use This Pattern

When you need to add an element at the start of a fixed-size list, use the shifting pattern to make space.

Common Mistakes

Mistake: Shifting elements from left to right causing overwriting
Fix: Shift elements from right to left to preserve data

Mistake: Not checking for full array before insertion
Fix: Add capacity check before shifting and inserting

Summary

Inserts a new element at the start by shifting existing elements right.

Use when you need to add items at the beginning of an array with fixed size.

Shift elements from the end backward to avoid overwriting data.