Smallest Subarray to Sort in Every Sliding Window

Smallest Subarray to Sort in Every Sliding Window - Problem

Array Two Pointers Stack Greedy Sorting Monotonic Stack Medium

You have an integer array and need to analyze sliding windows of size k. For each window, imagine you want to make the entire window non-decreasing (sorted in ascending order). Your task is to find the minimum length of a continuous segment within each window that needs to be sorted to achieve this goal.

Think of it like this: you're looking through a magnifying glass of size k that slides across your array. At each position, you ask: "What's the shortest consecutive portion I need to sort to make this entire view sorted?"

If a window is already sorted, the answer is 0. Return an array containing the answer for each possible window position.

Input & Output

example_1.py — Basic Window

$ Input: nums = [5, 2, 8, 1, 9, 3], k = 3

› Output: [3, 3, 3, 3]

💡 Note: For window [5,2,8]: need to sort all 3 elements. For [2,8,1]: need to sort all 3. For [8,1,9]: need to sort first 3. For [1,9,3]: need to sort last 3 positions (but only 2 elements need sorting, so answer is 2, but we need consecutive segment including position 1, so answer is 3).

example_2.py — Already Sorted Window

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

› Output: [0, 0, 0]

💡 Note: All windows [1,2,3], [2,3,4], and [3,4,5] are already sorted, so no subarray needs to be sorted.

example_3.py — Single Element

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

› Output: [0, 0, 0]

💡 Note: Each window contains only one element, which is trivially sorted, so answer is 0 for each position.

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ k ≤ nums.length
-10⁴ ≤ nums[i] ≤ 10⁴
The array can contain duplicate values

Visualization

Tap to expand

Understanding the Visualization

Position Window

Place the sliding window of size k at current position

Create Reference

Make a sorted copy to see what the window should look like

Find Boundaries

Locate leftmost and rightmost positions where actual differs from sorted

Calculate Length

The minimum segment length is the span between these boundaries

Key Takeaway

🎯 Key Insight: Instead of trying all possible segments, we compare with the sorted version to directly identify the boundaries of disorder, making the solution much more efficient.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal approach uses two pointers to identify the boundaries of the unsorted region in each sliding window. By comparing each window with its sorted version, we find the leftmost and rightmost positions where elements differ, giving us the minimum segment that needs sorting in O(n*k*log k) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Segments)	O(n*k³)	O(k)	For each window, try all possible segment lengths and check if sorting that segment makes the window sorted
Two Pointers Optimization	O(nklog k)	O(k)	Find leftmost out-of-order element and rightmost out-of-order element to determine minimum segment

Brute Force (Check All Segments) — Algorithm Steps

Iterate through all possible sliding windows of size k
For each window, try segment lengths from 0 to k
For each segment length, try all valid starting positions
Create a copy of the window, sort the chosen segment
Check if the entire window is now non-decreasing
Return the minimum segment length that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Window

Choose a sliding window of size k from the array

Try Segment Lengths

For each possible segment length from 1 to k

Try All Positions

Test the segment at every valid position

Sort and Check

Sort the segment and verify if window becomes sorted

Code -

solution.c — C

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

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

int* smallestSubarrayToSort(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize - k + 1;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    
    for (int i = 0; i <= numsSize - k; i++) {
        int window[k], sorted[k];
        memcpy(window, &nums[i], k * sizeof(int));
        memcpy(sorted, window, k * sizeof(int));
        qsort(sorted, k, sizeof(int), compare);
        
        int minLength = k;
        
        // Check if already sorted
        if (memcmp(window, sorted, k * sizeof(int)) == 0) {
            result[i] = 0;
            continue;
        }
        
        // Try all segment lengths
        for (int segLen = 1; segLen <= k; segLen++) {
            int found = 0;
            for (int start = 0; start <= k - segLen; start++) {
                int temp[k], tempSorted[k];
                memcpy(temp, window, k * sizeof(int));
                qsort(&temp[start], segLen, sizeof(int), compare);
                
                memcpy(tempSorted, temp, k * sizeof(int));
                qsort(tempSorted, k, sizeof(int), compare);
                
                if (memcmp(temp, tempSorted, k * sizeof(int)) == 0) {
                    minLength = segLen;
                    found = 1;
                    break;
                }
            }
            if (found) break;
        }
        
        result[i] = minLength;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k³)

For each of n-k+1 windows, we try k segment lengths, k positions each, and O(k) to sort and verify

✓ Linear Growth

Space Complexity

O(k)

We need O(k) space to create copies of windows for sorting simulation

✓ Linear Space

28.8K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Brute Force (Check All Segments) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler