Wiggle Sort II

Wiggle Sort II - Problem

Given an integer array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3]...

The wiggle pattern means elements at even indices should be smaller than their next element, and elements at odd indices should be larger than their next element.

You may assume the input array always has a valid answer.

Input & Output

Example 1 — Basic Wiggle Pattern

$ Input: nums = [1,5,1,1,6,4]

› Output: [1,6,1,5,1,4]

💡 Note: One possible wiggle sort: 1 < 6 > 1 < 5 > 1 < 4. Each even index is smaller than the next odd index, and each odd index is larger than the next even index.

Example 2 — Small Array

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

› Output: [2,3,1,3,1,2]

💡 Note: After sorting [1,1,2,2,3,3], we arrange as wiggle: 2 < 3 > 1 < 3 > 1 < 2. Smaller elements at even positions, larger at odd positions.

Example 3 — Minimum Size

$ Input: nums = [1,2]

› Output: [1,2]

💡 Note: For two elements, we need nums[0] < nums[1], so [1,2] already satisfies the wiggle condition.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 5000
It is guaranteed that there will be an answer for the given input.

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to arrange elements in a wiggle pattern where nums[0] < nums[1] > nums[2] < nums[3]... The optimal approach uses virtual indexing with quickselect to achieve O(n) time and O(1) space by directly placing elements without extra sorting. Time: O(n), Space: O(1)

Common Approaches

✓ Sort and Rearrange

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

Sort the entire array, then create wiggle pattern by placing smaller half in even positions and larger half in odd positions. Use reverse placement to avoid neighbor conflicts.

Virtual Indexing with Quickselect

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

Find the median using quickselect in O(n) time, then use virtual indexing to map wiggle positions directly to sorted positions without creating a separate sorted array.

Sort and Rearrange — Algorithm Steps

Sort the array
Place smaller elements at even indices in reverse order
Place larger elements at odd indices in reverse order

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort elements to prepare for placement

Place Elements

Put smaller half at even indices, larger half at odd indices

Wiggle Pattern

Result satisfies nums[i] < nums[i+1] > nums[i+2]

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);
}

void solution(int* nums, int numsSize, int* result) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Place smaller half at even indices (reverse order)
    int mid = (numsSize + 1) / 2;
    int j = mid - 1;
    for (int i = 0; i < numsSize; i += 2) {
        result[i] = nums[j];
        j--;
    }
    
    // Place larger half at odd indices (reverse order)
    j = numsSize - 1;
    for (int i = 1; i < numsSize; i += 2) {
        result[i] = nums[j];
        j--;
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    int nums[100], numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result[100];
    solution(nums, numsSize, result);
    
    printf("[");
    for (int i = 0; i < numsSize; i++) {
        printf("%d", result[i]);
        if (i < numsSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates with O(n log n), arrangement is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Need extra array to store the rearranged result

⚡ Linearithmic Space

87.0K Views

Medium Frequency

~25 min Avg. Time

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

Sort and Rearrange — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler