Array Insertion at Beginning in DSA Java - Execution Trace

Concept Flow - Array Insertion at Beginning

Check if array has space

Yes↓

Shift all elements right by 1

↓

Insert new element at index 0

↓

Done

No↓

Resize array or error

Start by checking if there is space. If yes, shift all elements one step right. Then insert the new element at the start.

Execution Sample

DSA Java

int[] arr = {10, 20, 30, 40, 0};
int n = 4;
int x = 5;
// Insert x at beginning
for (int i = n - 1; i >= 0; i--) arr[i + 1] = arr[i];
arr[0] = x;
n++;

This code inserts 5 at the beginning of the array by shifting elements right.

Execution Table

Step	Operation	Array Elements	Pointer Changes	Visual State
1	Check space for insertion	10, 20, 30, 40	n=4	[10, 20, 30, 40, _]
2	Shift element at index 3 to index 4	10, 20, 30, 40	arr[4]=arr[3]	[10, 20, 30, 40, 40]
3	Shift element at index 2 to index 3	10, 20, 30, 40	arr[3]=arr[2]	[10, 20, 30, 30, 40]
4	Shift element at index 1 to index 2	10, 20, 30, 40	arr[2]=arr[1]	[10, 20, 20, 30, 40]
5	Shift element at index 0 to index 1	10, 20, 30, 40	arr[1]=arr[0]	[10, 10, 20, 30, 40]
6	Insert new element 5 at index 0	10, 20, 30, 40	arr[0]=5	[5, 10, 20, 30, 40]
7	Increment size n	5, 10, 20, 30, 40	n=5	[5, 10, 20, 30, 40]
8	End	5, 10, 20, 30, 40	n=5	[5, 10, 20, 30, 40]

💡 All elements shifted right, new element inserted at index 0, size incremented.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
arr	[10, 20, 30, 40, _]	[10, 20, 30, 40, 40]	[10, 20, 30, 30, 40]	[10, 20, 20, 30, 40]	[10, 10, 20, 30, 40]	[5, 10, 20, 30, 40]	[5, 10, 20, 30, 40]
n	4	4	4	4	4	4	5

Key Moments - 3 Insights

Why do we shift elements from the end towards the beginning?

Shifting from the end prevents overwriting elements before they are moved. See steps 2 to 5 in execution_table where elements move right safely.

What happens if the array has no extra space?

Insertion cannot proceed without resizing or error. Step 1 checks space; if no space, resizing or error handling is needed.

Why do we increment the size variable after insertion?

Because the array now logically contains one more element. Step 7 shows n incremented to reflect new size.

Visual Quiz - 3 Questions

Look at the execution_table at Step 4, what is the array state?

A [10, 20, 30, 30, 40]

B [10, 20, 20, 30, 40]

C [10, 10, 20, 30, 40]

D [5, 10, 20, 30, 40]

💡 Hint

Check the Visual State column at Step 4 in execution_table.

At which step is the new element inserted at index 0?

A Step 5

B Step 7

C Step 6

D Step 2

💡 Hint

Look for the operation mentioning insertion at index 0 in execution_table.

If the array size variable n was not incremented, what would happen?

A The array would have an incorrect size count

B The elements would not shift

C The array would lose the first element

D The new element would be inserted at the end

💡 Hint

Refer to variable_tracker row for n and step 7 in execution_table.

Concept Snapshot

Array Insertion at Beginning:
- Check if space available
- Shift all elements right from end to start
- Insert new element at index 0
- Increment size variable
- Shifting prevents overwriting data
- Requires resizing if no space

Full Transcript

To insert an element at the beginning of an array, first check if there is space. If yes, shift all elements one position to the right starting from the last element to avoid overwriting. Then place the new element at index zero. Finally, increase the size count to reflect the new element. If no space is available, resizing or error handling is needed. This process ensures the array maintains all elements correctly with the new element at the start.

Practice

1. What happens when you insert an element at the beginning of a fixed-size array in Java?

easy

A. The new element replaces the first element without shifting others.

B. The array size automatically increases to fit the new element.

C. All existing elements shift one position to the right to make space.

D. The last element is removed to insert the new element at the start.

Solution

1. Step 1: Understand fixed-size array behavior

   Java arrays have fixed size, so to insert at the start, elements must move to make space.

2. Step 2: Describe element shifting

   All elements shift one position right to free index 0 for the new element.

3. Final Answer:

   All existing elements shift one position to the right to make space. -> Option C

4. Quick Check:

   Insert at start = shift right [OK]

Hint: Insert at start means shift all elements right [OK]

Common Mistakes:

• Thinking array size grows automatically
• Replacing first element without shifting
• Removing last element silently

2. Which of the following Java code snippets correctly inserts an element 10 at the beginning of an integer array arr of size 5?

easy

A. arr[arr.length] = 10; // Insert at end

B. for(int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i+1]; } arr[arr.length-1] = 10;

C. arr[0] = 10; for(int i = 1; i < arr.length; i++) { arr[i] = arr[i-1]; }

D. for(int i = arr.length - 1; i > 0; i--) { arr[i] = arr[i-1]; } arr[0] = 10;

Solution

1. Step 1: Identify correct shifting direction

   To insert at start, shift elements right from end to start to avoid overwriting.

2. Step 2: Check code correctness

   for(int i = arr.length - 1; i > 0; i--) { arr[i] = arr[i-1]; } arr[0] = 10; shifts elements right correctly, then inserts 10 at index 0.

3. Final Answer:

   for(int i = arr.length - 1; i > 0; i--) { arr[i] = arr[i-1]; } arr[0] = 10; -> Option D

4. Quick Check:

   Shift right from end, then insert [OK]

Hint: Shift right from end to start before inserting [OK]

Common Mistakes:

• Shifting left instead of right
• Overwriting elements before shifting
• Trying to insert at arr[arr.length] (out of bounds)

3. What will be the output of the following Java code?

int[] arr = {5, 6, 7, 8, 9};
for(int i = arr.length - 1; i > 0; i--) {
  arr[i] = arr[i-1];
}
arr[0] = 1;
for(int num : arr) {
  System.out.print(num + " ");
}

medium

A. 1 6 7 8 9

B. 1 5 6 7 8

C. 5 6 7 8 9

D. 9 5 6 7 8

Solution

1. Step 1: Trace the shifting loop

   Loop shifts elements right: arr[4]=arr[3]=8, arr[3]=arr[2]=7, arr[2]=arr[1]=6, arr[1]=arr[0]=5.

2. Step 2: Insert 1 at index 0

   arr[0] = 1 replaces original 5.

3. Final Answer:

   1 5 6 7 8 -> Option B

4. Quick Check:

   Shift right + insert 1 at start = 1 5 6 7 8 [OK]

Hint: Shift right then insert new element at index 0 [OK]

Common Mistakes:

• Not shifting elements before insertion
• Overwriting elements incorrectly
• Confusing output order

4. Identify the error in the following code that tries to insert 20 at the beginning of array arr.

int[] arr = {2, 4, 6, 8, 10};
for(int i = 0; i < arr.length - 1; i++) {
  arr[i+1] = arr[i];
}
arr[0] = 20;

medium

A. The loop should start from the end to avoid overwriting.

B. The loop shifts elements left, overwriting data incorrectly.

C. The array size is too small to insert a new element.

D. No error; code works correctly.

Solution

1. Step 1: Analyze loop direction

   The loop shifts elements from start to end, causing overwriting of values before they move.

2. Step 2: Correct loop direction

   To avoid overwriting, loop must run backward from end to start.

3. Final Answer:

   The loop should start from the end to avoid overwriting. -> Option A

4. Quick Check:

   Shift right requires backward loop [OK]

Hint: Shift right means loop backward from end [OK]

Common Mistakes:

• Looping forward causes data overwrite
• Ignoring array size limits
• Assuming code works without shifting properly

5. Given a fixed-size array arr of length 6 with elements {3, 5, 7, 9, 11, 13}, you want to insert 1 at the beginning without losing any data. Which approach correctly handles this?

hard

A. Create a new array of size 7, copy all elements shifted by one, then insert 1 at index 0.

B. Shift elements right in the same array and insert 1 at index 0, overwriting the last element.

C. Replace the first element with 1 without shifting others.

D. Insert 1 at index 6 directly, ignoring array size.

Solution

1. Step 1: Understand fixed-size array limits

   Java arrays cannot grow; to keep all data, a bigger array is needed.

2. Step 2: Copy elements to new array shifted by one

   Create new array size 7, copy old elements starting at index 1, insert 1 at index 0.

3. Final Answer:

   Create a new array of size 7, copy all elements shifted by one, then insert 1 at index 0. -> Option A

4. Quick Check:

   New bigger array + shift + insert = no data loss [OK]

Hint: Use bigger array to avoid data loss when inserting [OK]

Common Mistakes:

• Overwriting last element in fixed array
• Ignoring array size limits
• Trying to insert out of bounds