Find the Middle Index in Array - Practice Coding Problems

Find the Middle Index in Array - Problem

Imagine you're standing on a balance beam trying to find the perfect equilibrium point. In this problem, you need to find the leftmost middle index in an integer array where the sum of elements on the left equals the sum of elements on the right.

Given a 0-indexed integer array nums, your task is to find the smallest index middleIndex such that:

nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1]

Special cases:

If middleIndex == 0, the left side sum is considered 0
If middleIndex == nums.length - 1, the right side sum is considered 0

Return the leftmost middleIndex that satisfies the condition, or -1 if no such index exists.

Example: For array [2, 3, -1, 8, 4], index 3 is the middle index because left sum = 2+3+(-1) = 4 and right sum = 4.

Input & Output

example_1.py — Basic Case

$ Input: [2, 3, -1, 8, 4]

› Output: 3

💡 Note: At index 3, left sum = 2 + 3 + (-1) = 4, right sum = 4. Both sums are equal, so index 3 is the middle index.

example_2.py — No Middle Index

$ Input: [1, -1, 4]

› Output: -1

💡 Note: No index satisfies the condition. At index 0: left=0, right=3. At index 1: left=1, right=4. At index 2: left=0, right=0. None have equal left and right sums.

example_3.py — Edge Case - Single Element

$ Input: [2]

› Output: 0

💡 Note: For a single element array, index 0 is the middle index since both left sum (0) and right sum (0) are equal.

Visualization

Tap to expand

Understanding the Visualization

Calculate Total Weight

Sum all children's weights: 2+3+(-1)+8+4 = 16 units

Try Each Position

Move the fulcrum and check if both sides balance

Found Balance

At position 3, left weight (4) equals right weight (4)

Key Takeaway

🎯 Key Insight: Instead of recalculating sums repeatedly, use the mathematical relationship: right_sum = total_sum - left_sum - current_element to find the balance point efficiently in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: one to calculate total sum, one to find the middle index

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track sums, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
Note: Array can contain negative numbers

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses prefix sum technique to solve this problem in O(n) time and O(1) space. Calculate the total sum first, then iterate through the array maintaining a running left sum. For each position, calculate the right sum using the formula: right_sum = total_sum - left_sum - current_element. Return the first index where left and right sums are equal.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum (Optimal)	O(n)	O(1)	Use prefix sum to calculate left and right sums efficiently in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	For each index, calculate left and right sums separately

Prefix Sum (Optimal) — Algorithm Steps

Calculate the total sum of all elements in the array
Initialize left_sum to 0 and iterate through the array
For each index, calculate right_sum = total_sum - left_sum - nums[i]
If left_sum equals right_sum, return the current index
Update left_sum by adding the current element for the next iteration

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total

Find the sum of all elements: 2+3+(-1)+8+4 = 16

Iterate with Running Sum

For each position, track left_sum and calculate right_sum = total - left - current

Check Balance

At index 3: left_sum = 4, right_sum = 16-4-8 = 4, they match!

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int findMiddleIndex(int* nums, int numsSize) {
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    
    int leftSum = 0;
    for (int i = 0; i < numsSize; i++) {
        // Right sum = total - left - current
        int rightSum = totalSum - leftSum - nums[i];
        
        if (leftSum == rightSum) {
            return i;
        }
        
        // Update left sum for next iteration
        leftSum += nums[i];
    }
    
    return -1;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    
    while ((c = getchar()) != '\n') {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            sign = -1;
        } else if (c == ',' || c == ']') {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
        }
    }
    
    printf("%d\n", findMiddleIndex(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: one to calculate total sum, one to find the middle index

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track sums, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
Note: Array can contain negative numbers

67.2K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler