Minimum Adjacent Swaps to Make a Valid Array

Minimum Adjacent Swaps to Make a Valid Array - Problem

Array Greedy Medium

You are given a 0-indexed integer array nums. Your goal is to transform it into a valid array using the minimum number of adjacent swaps.

A valid array must satisfy both conditions:

The largest element (or any of the largest if there are duplicates) must be at the rightmost position
The smallest element (or any of the smallest if there are duplicates) must be at the leftmost position

An adjacent swap exchanges two neighboring elements in the array. Return the minimum number of adjacent swaps required to make the array valid.

Example: For array [3, 4, 1, 2], we need to move 1 to the front and 4 to the back, requiring 4 swaps total.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,4,1,2]

› Output: 4

💡 Note: Min element 1 is at position 2, needs 2 swaps to reach position 0. Max element 4 is at position 1, needs 2 swaps to reach position 3. Since min position (2) > max position (1), their paths cross, so we save 1 swap. Total: 2 + 2 - 1 = 3 swaps.

example_2.py — Already Valid

$ Input: nums = [1,2,3]

› Output: 0

💡 Note: Array is already valid: minimum 1 is at leftmost position, maximum 3 is at rightmost position. No swaps needed.

example_3.py — Single Element

$ Input: nums = [5]

› Output: 0

💡 Note: Single element array is always valid since the element is both minimum and maximum, and it's already in both leftmost and rightmost positions.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Adjacent swaps only: Can only exchange neighboring elements

Visualization

Tap to expand

Understanding the Visualization

Identify Targets

Find the positions of the optimal min and max elements to move

Calculate Individual Costs

Count swaps needed to move each element to its target position

Optimize Path Crossing

If paths intersect, we can save one swap by letting them pass each other

Return Total Cost

Sum up the swaps needed with crossing optimization applied

Key Takeaway

🎯 Key Insight: By identifying the optimal positions for min and max elements and recognizing when their movement paths intersect, we can minimize the total number of adjacent swaps needed to create a valid array.

Asked in

G Google 35 a Amazon 42 f Meta 28 ⊞ Microsoft 31

The optimal solution uses a two-pass greedy approach to find the leftmost minimum and rightmost maximum elements, then calculates the minimum swaps needed while handling the special case where their movement paths cross. This achieves O(n) time complexity with O(1) space, making it highly efficient for large arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Two-Pass Solution	O(n)	O(1)	Find optimal min/max positions in two passes for minimum swaps
Brute Force (Find All Elements)	O(n²)	O(n)	Find all min/max positions and try all combinations to find minimum swaps

Optimized Two-Pass Solution — Algorithm Steps

First pass: find min value and its leftmost position
Second pass: find max value and its rightmost position
Calculate swaps needed to move min element to position 0
Calculate swaps needed to move max element to last position
Handle overlap case where movements might interfere with each other

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass (Left to Right)

Find minimum value and its leftmost occurrence

Second Pass (Right to Left)

Find maximum value and its rightmost occurrence

Calculate Swaps

Compute swaps needed for optimal positioning

Handle Overlap

Adjust for cases where movement paths intersect

Code -

solution.c — C

int minimumSwaps(int* nums, int numsSize) {
    if (numsSize <= 1) return 0;
    
    // First pass: find min value and its leftmost position
    int minVal = INT_MAX;
    int minPos = -1;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) {
            minVal = nums[i];
            minPos = i;
        }
    }
    
    // Second pass: find max value and its rightmost position
    int maxVal = INT_MIN;
    int maxPos = -1;
    for (int i = numsSize - 1; i >= 0; i--) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
            maxPos = i;
        }
    }
    
    int swapsForMin = minPos;
    int swapsForMax = (numsSize - 1) - maxPos;
    
    int totalSwaps = swapsForMin + swapsForMax;
    
    if (minPos > maxPos) {
        totalSwaps -= 1;
    }
    
    return totalSwaps;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array to find optimal positions

✓ Linear Growth

Space Complexity

O(1)

Only storing a few position variables

✓ Linear Space

42.4K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Two-Pass Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler