Find Pivot Index: Prefix Sum Balance Point

Find Pivot Index is LeetCode problem 724. Given an array of integers, find the pivot index where the sum of elements to the left equals the sum of elements to the right. If no such index exists, return -1.

The problem

Given an integer array nums, return the leftmost pivot index. The pivot index is where the sum of all numbers strictly to the left equals the sum of all numbers strictly to the right. If the index is on the left edge, the left sum is 0. Similarly for the right edge.

Example: nums = [1, 7, 3, 6, 5, 6]. The pivot index is 3 because the left sum (1 + 7 + 3 = 11) equals the right sum (5 + 6 = 11).

The approach: prefix sum

Compute the total sum first. Then scan left to right, tracking left_sum. At each index, right_sum = total - left_sum - nums[i]. If left_sum equals right_sum, you found the pivot.

Visual walkthrough

The code

def pivot_index(nums):
    total = sum(nums)
    left_sum = 0

    for i in range(len(nums)):
        if left_sum == total - left_sum - nums[i]:
            return i
        left_sum += nums[i]

    return -1

Key details to notice:

• You compute total once, then derive right_sum from total, left_sum, and nums[i]
• left_sum is updated AFTER the check, so it represents the sum of elements strictly to the left
• The first index with matching sums is returned (leftmost pivot)

Complexity analysis

The building blocks

Prefix sums

The prefix sum pattern converts "sum of a range" queries into O(1) lookups. Here you don't store the full prefix array because you only need the running left sum and can derive the right sum from the total.

This pattern appears in:

• Range Sum Query - Immutable (LeetCode 303) for range sum queries
• Subarray Sum Equals K (LeetCode 560) using prefix sum with a hash map
• Product of Array Except Self (LeetCode 238) for prefix/suffix products

Edge cases to watch for

• Pivot at index 0. Left sum is 0. Right sum is total minus nums[0]. If they match, return 0.
• Pivot at last index. Right sum is 0. Left sum is total minus nums[-1].
• Negative numbers. The algorithm handles negatives naturally since it uses sum arithmetic.
• Single element. [1]. Left sum = 0, right sum = 0. Return 0.
• No pivot exists. [1, 2, 3]. Return -1.

From understanding to recall

Find Pivot Index is a clean application of the prefix sum pattern. The key insight is that you do not need to store a prefix sum array because you can derive the right sum from the total and the running left sum. This "total minus partial" trick appears frequently in array problems.

Reading the solution once gives you the idea, but writing it from scratch under pressure requires remembering the exact update order: check first, then increment left_sum. Spaced repetition drills lock in these ordering details so you do not second-guess yourself during interviews.

Related posts

• Subarray Sum Equals K - Prefix sums with a hash map for counting, LeetCode 560
• Product of Array Except Self - Prefix and suffix products in a single array, LeetCode 238
• Range Sum Query - Immutable - Precomputed prefix sums for O(1) range queries, LeetCode 303

---

Visual Learner? Explore how prefix sum algorithms work with our Array Interactive Visualization.