Shortest Unsorted Continuous Subarray - Practice Coding Problems

Shortest Unsorted Continuous Subarray - Problem

Array Two Pointers Stack Greedy Sorting Monotonic Stack Medium

You're given an integer array that's almost sorted, but not quite. Your task is to find the shortest continuous subarray that, if sorted, would make the entire array perfectly sorted in non-decreasing order.

Think of it as finding the "messy middle" of an otherwise organized array. For example, in [2, 6, 4, 8, 10, 9, 15], if we sort just the subarray [6, 4, 8, 10, 9] to get [4, 6, 8, 9, 10], the entire array becomes sorted: [2, 4, 6, 8, 9, 10, 15].

Goal: Return the length of this shortest subarray. If the array is already sorted, return 0.

Input & Output

example_1.py — Standard Case

$ Input: [2, 6, 4, 8, 10, 9, 15]

› Output: 5

💡 Note: The subarray [6, 4, 8, 10, 9] needs to be sorted. When sorted to [4, 6, 8, 9, 10], the entire array becomes [2, 4, 6, 8, 9, 10, 15] which is sorted.

example_2.py — Already Sorted

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

› Output: 0

💡 Note: The array is already sorted in non-decreasing order, so no subarray needs to be sorted. Return 0.

example_3.py — Reverse Sorted

$ Input: [3, 2, 1]

› Output: 3

💡 Note: The entire array needs to be sorted since it's in reverse order. The shortest subarray is the entire array itself with length 3.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵
Follow-up: Can you solve it in O(n) time complexity?

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

The array is mostly sorted but has a 'messy middle' section

Find Left Boundary

Scan right and mark where elements are smaller than expected

Find Right Boundary

Scan left and mark where elements are larger than expected

Calculate Length

The distance between boundaries gives us the answer

Key Takeaway

🎯 Key Insight: We don't need to actually sort anything - just find where the order breaks down by tracking the rightmost "too small" element and leftmost "too large" element in a single pass!

Asked in

G Google 47 a Amazon 38 ⊞ Microsoft 29 Apple 22

The optimal solution uses a single-pass approach with O(n) time and O(1) space. By scanning left-to-right to find elements smaller than the maximum seen so far, and right-to-left to find elements larger than the minimum seen so far, we can identify the exact boundaries of the unsorted subarray without needing to sort or use extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Boundary Detection (Optimal)	O(n)	O(1)	Find boundaries in one pass by tracking min/max elements that are out of place
Brute Force (Try All Subarrays)	O(n³)	O(n)	Check every possible subarray to see if sorting it makes the whole array sorted
Sorting + Comparison (Two Pointers)	O(n log n)	O(n)	Create sorted copy and find first/last positions where arrays differ

Single Pass Boundary Detection (Optimal) — Algorithm Steps

Scan left to right: track maximum seen so far, mark positions where current < max
Scan right to left: track minimum seen so far, mark positions where current > min
Find leftmost position where an element needs to move right
Find rightmost position where an element needs to move left
Return the distance between these boundaries

Visualization

Tap to expand

Step-by-Step Walkthrough

Left-to-right scan

Track max seen so far, mark where current < max

Right-to-left scan

Track min seen so far, mark where current > min

Find boundaries

Rightmost violation from step 1, leftmost from step 2

Calculate result

Distance between boundaries gives the answer

Code -

solution.c — C

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

int findUnsortedSubarray(int* nums, int numsSize) {
    int left = -1, right = -1;
    int maxSoFar = nums[0], minSoFar = nums[numsSize-1];
    
    // Left to right
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] < maxSoFar) {
            right = i;
        } else {
            maxSoFar = nums[i];
        }
    }
    
    // Right to left
    for (int i = numsSize - 2; i >= 0; i--) {
        if (nums[i] > minSoFar) {
            left = i;
        } else {
            minSoFar = nums[i];
        }
    }
    
    return right == -1 ? 0 : right - left + 1;
}

int main() {
    int n;
    scanf("%d", &n);
    int *nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    printf("%d\n", findUnsortedSubarray(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array - one left to right, one right to left

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables to track boundaries and min/max values

✓ Linear Space

52.3K Views

High Frequency

~18 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

Single Pass Boundary Detection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler