Shortest Unsorted Continuous Subarray

Shortest Unsorted Continuous Subarray - Problem

Array Two Pointers Stack Greedy Sorting Monotonic Stack Medium

Given an integer array nums, you need to find one continuous subarray such that if you only sort this subarray in non-decreasing order, then the whole array will be sorted in non-decreasing order.

Return the length of the shortest such subarray.

Note: The array may already be sorted, in which case the answer is 0.

Input & Output

Example 1 — Basic Unsorted Middle

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

› Output: 5

💡 Note: Need to sort subarray [6,4,8,10,9] from index 1 to 5. After sorting it becomes [4,6,8,9,10], making the whole array [2,4,6,8,9,10,15] which is fully sorted. Length = 5.

Example 2 — Already Sorted

$ Input: nums = [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 — Entire Array Unsorted

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

› Output: 5

💡 Note: The entire array is in reverse order. We need to sort the whole array [5,4,3,2,1] to get [1,2,3,4,5]. Length = 5.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 25 f Facebook 18

The key insight is finding elements that violate sorted order: elements smaller than the maximum seen so far (from left), and elements larger than the minimum seen so far (from right). The optimal two pointers approach runs in O(n) time with O(1) space by tracking these boundary violations in two passes.

Common Approaches

✓ Check All Subarrays

⏱️ Time: O(n⁴) Space: O(n)

For each possible subarray, create a copy, sort just that subarray, and check if the entire array becomes sorted. Return the minimum length found.

Compare with Sorted Array

⏱️ Time: O(n log n) Space: O(n)

Create a sorted copy of the array and compare it with the original. Find the first and last positions where they differ - this gives us the boundaries of the unsorted subarray.

Two Pointers Optimal

⏱️ Time: O(n) Space: O(1)

Scan from left to find elements smaller than the running maximum, and from right to find elements larger than the running minimum. The boundaries of these out-of-place elements define our subarray.

Check All Subarrays — Algorithm Steps

Step 1: Try all possible subarrays from index i to j
Step 2: For each subarray, sort it and check if whole array is sorted
Step 3: Keep track of minimum length that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Subarray

Test sorting each possible subarray

Check Sorted

Verify if whole array becomes sorted

Find Minimum

Return shortest length that works

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* nums, int numsSize) {
    if (numsSize <= 1) return 0;
    
    // First check if array is already sorted
    int alreadySorted = 1;
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] > nums[i + 1]) {
            alreadySorted = 0;
            break;
        }
    }
    
    if (alreadySorted) {
        return 0;
    }
    
    int minLen = numsSize;
    
    // Try all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Copy array and sort subarray from i to j
            int* temp = (int*)malloc(numsSize * sizeof(int));
            memcpy(temp, nums, numsSize * sizeof(int));
            qsort(temp + i, j - i + 1, sizeof(int), compare);
            
            // Check if entire array is now sorted
            int isSorted = 1;
            for (int k = 0; k < numsSize - 1; k++) {
                if (temp[k] > temp[k + 1]) {
                    isSorted = 0;
                    break;
                }
            }
            
            if (isSorted) {
                int len = j - i + 1;
                if (len < minLen) minLen = len;
            }
            
            free(temp);
        }
    }
    
    return minLen;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array from format [2,6,4,8,10,9,15]
    int nums[1000];
    int count = 0;
    char* ptr = line;
    
    // Find the opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++; // Skip the '['
    
    // Parse numbers until we hit ']' or end of string
    while (*ptr && *ptr != ']' && *ptr != '\n') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\t')) ptr++;
        
        // If we hit the end bracket or newline, break
        if (*ptr == ']' || *ptr == '\n' || *ptr == '\0') break;
        
        // Parse the number
        if (isdigit(*ptr) || *ptr == '-') {
            char* endptr;
            nums[count] = (int)strtol(ptr, &endptr, 10);
            count++;
            ptr = endptr;
        } else {
            ptr++;
        }
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n²) subarrays × O(n log n) sorting × O(n) verification

✓ Linear Growth

Space Complexity

O(n)

Extra array for copying and sorting subarrays

⚡ Linearithmic Space

197.2K Views

High Frequency

~25 min Avg. Time

6.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

Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler