Array Deletion at Middle Index in DSA Typescript

Mental Model

To delete an element in the middle of an array, we shift all elements after it one step to the left to fill the gap.

Analogy: Imagine a row of chairs where one person leaves from the middle; everyone behind that person moves one seat forward to close the empty spot.

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

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], delete element at index 2

Goal: Remove the element at index 2 and shift remaining elements left

Step 1: Start deletion at index 2 (value 3)

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

Why: We identify the element to remove

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

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

Why: Fill the gap by moving next element left

Step 3: Shift element at index 4 (value 5) to index 3

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

Why: Continue shifting elements left to close gap

Step 4: Remove last duplicate element at index 4

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

Why: Array size reduces by one after deletion

Result:

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

Annotated Code

DSA Typescript

class ArrayDeletion {
  static deleteAtMiddle(arr: number[], index: number): number[] {
    if (index < 0 || index >= arr.length) {
      return arr; // index out of bounds, no deletion
    }
    for (let i = index; i < arr.length - 1; i++) {
      arr[i] = arr[i + 1]; // shift element left to fill gap
    }
    arr.pop(); // remove last duplicate element
    return arr;
  }
}

// Driver code
const inputArray = [1, 2, 3, 4, 5];
const deleteIndex = 2;
const result = ArrayDeletion.deleteAtMiddle(inputArray, deleteIndex);
console.log(result.join(' -> ') + ' -> null');

if (index < 0 || index >= arr.length) { return arr; }

Check if index is valid to avoid errors

for (let i = index; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; }

Shift elements left starting from deletion index

arr.pop();

Remove last element which is now duplicate

Output

1 -> 2 -> 4 -> 5 -> null

Complexity Analysis

Time: O(n) because we may need to shift up to n-1 elements after the deleted index

Space: O(1) because deletion is done in place without extra storage

vs Alternative: Compared to creating a new array without the element (O(n) time and O(n) space), this method saves space by modifying the original array

Edge Cases

Deleting at index 0 (first element)

All elements shift left, first element removed

DSA Typescript

if (index < 0 || index >= arr.length) { return arr; }

Deleting at last index

No shifting needed, just pop last element

DSA Typescript

if (index < 0 || index >= arr.length) { return arr; }

Deleting with invalid index (negative or too large)

Array remains unchanged

DSA Typescript

if (index < 0 || index >= arr.length) { return arr; }

When to Use This Pattern

When you need to remove an element from the middle of an array and keep order, use shifting to fill the gap because arrays have fixed positions.

Common Mistakes

Mistake: Not shifting elements after deletion index, leaving a gap
Fix: Shift all elements after the deleted index one position left

Mistake: Not reducing array size after shifting, causing duplicate last element
Fix: Remove the last element using pop() after shifting

Summary

Deletes an element at a given middle index by shifting subsequent elements left.

Use when you want to remove an element from an array while preserving order.

The key is to shift elements left to close the gap, then reduce the array size.

Practice

1. What does deleting the middle element from an array mean?
Example: [1, 2, 3, 4, 5] Delete the middle element.

easy

A. Remove the element at index 2 (value 3) from the array

B. Remove the first element (value 1) from the array

C. Remove the last element (value 5) from the array

D. Remove all elements except the middle one

Solution

1. Step 1: Identify the middle index of the array

   The array has 5 elements, so middle index = floor(5/2) = 2.

2. Step 2: Remove the element at the middle index

   Removing element at index 2 removes the value 3 from the array.

3. Final Answer:

   Remove the element at index 2 (value 3) from the array -> Option A

4. Quick Check:

   Middle index = 2, remove element 3 [OK]

Hint: Middle index = floor(length/2), remove that element [OK]

Common Mistakes:

• Removing first or last element instead of middle
• Using length/2 without floor for odd length
• Confusing index with value

2. Which TypeScript code correctly deletes the middle element from array arr?

easy

A. arr.removeAt(Math.floor(arr.length / 2));

B. arr.splice(Math.floor(arr.length / 2), 1);

C. arr.delete(Math.floor(arr.length / 2));

D. arr.pop(Math.floor(arr.length / 2));

Solution

1. Step 1: Identify correct method to remove element by index in TypeScript

   TypeScript arrays use splice(index, count) to remove elements at a specific index.

2. Step 2: Use Math.floor(arr.length / 2) to get middle index

   This expression correctly calculates the middle index for deletion.

3. Final Answer:

   arr.splice(Math.floor(arr.length / 2), 1); -> Option B

4. Quick Check:

   splice + floor middle index = correct deletion [OK]

Hint: Use splice with floor(length/2) to delete middle [OK]

Common Mistakes:

• Using non-existent methods like delete or removeAt
• Using pop() which removes last element only
• Not flooring the middle index calculation

3. What is the output of this TypeScript code?

let arr = [10, 20, 30, 40, 50];
arr.splice(Math.floor(arr.length / 2), 1);
console.log(arr);

medium

A. [20, 30, 40, 50]

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

C. [10, 20, 30, 50]

D. [10, 20, 40, 50]

Solution

1. Step 1: Calculate middle index

   Array length is 5, so middle index = floor(5/2) = 2.

2. Step 2: Remove element at index 2

   Element at index 2 is 30, so removing it results in [10, 20, 40, 50].

3. Final Answer:

   [10, 20, 40, 50] -> Option D

4. Quick Check:

   Removed element 30 at index 2 [OK]

Hint: Remove element at floor(length/2) index [OK]

Common Mistakes:

• Not flooring index, causing wrong removal
• Removing wrong element index
• Expecting original array unchanged

4. Find the error in this code that tries to delete the middle element:

let arr = [5, 10, 15, 20];
arr.splice(arr.length / 2, 1);
console.log(arr);

medium

A. console.log syntax is incorrect

B. splice method does not exist on arrays

C. Using arr.length / 2 without floor causes wrong index

D. splice removes all elements, not one

Solution

1. Step 1: Check middle index calculation

   arr.length / 2 = 4 / 2 = 2 (number), but for even length arrays, middle index should be floor(4/2) = 2, so this seems correct but in TypeScript splice expects integer index.

2. Step 2: Verify if index is integer

   arr.length / 2 is 2 (integer), so no error here. But if length was odd, it would be float. The main issue is that for even length arrays, middle is ambiguous; usually floor is used to pick index 2.

3. Step 3: Identify actual problem

   In this code, no floor is used but division results in integer 2, so no error. However, if length was odd, index would be float causing error. So best practice is to use Math.floor to ensure integer index.

4. Final Answer:

   Using arr.length / 2 without floor causes wrong index -> Option C

5. Quick Check:

   Always floor middle index for splice [OK]

Hint: Always floor middle index before splice [OK]

Common Mistakes:

• Not flooring index causing float error
• Thinking splice removes all elements
• Misunderstanding console.log usage

5. Given an array arr of even length, how can you delete the lower middle element?
Example: arr = [2, 4, 6, 8] After deletion, output should be [2, 6, 8].

hard

A. arr.splice(Math.floor(arr.length / 2) - 1, 1);

B. arr.splice(Math.ceil(arr.length / 2), 1);

C. arr.splice(arr.length / 2, 1);

D. arr.splice(arr.length / 2 + 1, 1);

Solution

1. Step 1: Understand middle elements in even length array

   For even length 4, middle indices are 1 and 2 (0-based). Lower middle is index 1.

2. Step 2: Calculate index to delete

   Math.floor(4/2) = 2, subtract 1 to get lower middle index = 1.

3. Step 3: Use splice to delete element at index 1

   arr.splice(1, 1) removes element 4, resulting in [2, 6, 8].

4. Final Answer:

   arr.splice(Math.floor(arr.length / 2) - 1, 1); -> Option A

5. Quick Check:

   Lower middle index = floor(length/2)-1 [OK]

Hint: Lower middle = floor(length/2) - 1 for even arrays [OK]

Common Mistakes:

• Deleting upper middle instead of lower middle
• Not adjusting index for zero-based arrays
• Using ceil instead of floor