Codestin Search App

Wiggle Sort II - Problem

Given an integer array nums, transform it into a wiggle array where elements alternate between peaks and valleys in a strict pattern: nums[0] < nums[1] > nums[2] < nums[3] > nums[4] < nums[5]...

Think of it like creating a zigzag mountain range where each peak is higher than its neighboring valleys, and each valley is lower than its neighboring peaks. The pattern must be strictly alternating - no equal adjacent elements allowed!

Example: [1,5,1,1,6,4] → [1,6,1,5,1,4] creates the pattern: small < large > small < large > small < large

You're guaranteed that a valid wiggle arrangement always exists for the input array.

Input & Output

example_1.py — Basic Wiggle Sort

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

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

💡 Note: The output follows the wiggle pattern: 1 < 6 > 1 < 5 > 1 < 4. Each element at even index is smaller than its neighbors, and each element at odd index is larger than its neighbors.

example_2.py — Small Array

$ Input: [1,3,2]

› Output: [2,3,1]

💡 Note: For a 3-element array, we need: small < large > small. So 2 < 3 > 1 satisfies the wiggle condition perfectly.

example_3.py — Duplicate Elements

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

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

💡 Note: Even with duplicates, we can create a valid wiggle pattern by strategically placing elements: 2 < 3 > 1 < 3 > 1 < 2.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 5000
You may assume the input array always has a valid answer
The array is modified in-place with O(1) extra memory for the optimal solution

Asked in

The optimal approach uses a sort + two-pointers strategy with virtual indexing to create the perfect wiggle pattern. Key insight: median-based partitioning with reverse placement ensures no adjacent conflicts while maintaining the alternating small < large > small pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Quickselect + Optimal Placement	O(n)	O(n)	Use quickselect to find median, then place elements optimally without full sorting
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check which one satisfies the wiggle condition
Sort + Two Pointers Strategy	O(n log n)	O(n)	Sort array, then use strategic placement with two pointers to create wiggle pattern

Quickselect + Optimal Placement — Algorithm Steps

Use quickselect to find the median element in O(n) average time
Partition array into elements ≤ median and > median
Create virtual indexing to avoid conflicts between adjacent elements
Place smaller elements at even positions (valleys) in reverse order
Place larger elements at odd positions (peaks) in reverse order

Visualization

Tap to expand

Step-by-Step Walkthrough

Quickselect Median

Find median element without full sorting using quickselect algorithm

Three-way Partition

Partition elements into < median, = median, > median groups

Strategic Placement

Place elements using virtual indexing to create perfect wiggle pattern

Code -

solution.c — C

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

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

int partition(int* arr, int left, int right) {
    int pivot = arr[right];
    int i = left;
    for (int j = left; j < right; j++) {
        if (arr[j] <= pivot) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
        }
    }
    int temp = arr[i];
    arr[i] = arr[right];
    arr[right] = temp;
    return i;
}

int quickselect(int* arr, int left, int right, int k) {
    if (left == right) return arr[left];
    
    int pivotIndex = partition(arr, left, right);
    
    if (k == pivotIndex) return arr[k];
    else if (k < pivotIndex) return quickselect(arr, left, pivotIndex - 1, k);
    else return quickselect(arr, pivotIndex + 1, right, k);
}

int virtualIndex(int i, int n) {
    return (1 + 2 * i) % (n | 1);
}

void wiggleSort(int* nums, int size) {
    // For simplicity, use sorting approach in C
    int* sorted = (int*)malloc(size * sizeof(int));
    int* result = (int*)malloc(size * sizeof(int));
    
    for (int i = 0; i < size; i++) {
        sorted[i] = nums[i];
    }
    qsort(sorted, size, sizeof(int), compare);
    
    int mid = (size + 1) / 2;
    int left = mid - 1;
    int right = size - 1;
    
    for (int i = 0; i < size; i += 2) {
        result[virtualIndex(i, size)] = sorted[left--];
    }
    
    for (int i = 1; i < size; i += 2) {
        result[virtualIndex(i, size)] = sorted[right--];
    }
    
    for (int i = 0; i < size; i++) {
        nums[i] = result[i];
    }
    
    free(sorted);
    free(result);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) average for quickselect + O(n) for placement, O(n²) worst case

✓ Linear Growth

Space Complexity

O(n)

Space for result array and temporary storage during partitioning

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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