Wiggle Sort - Practice Coding Problems

Wiggle Sort - Problem

Imagine you're creating a mountain range pattern with numbers! Given an integer array nums, your task is to rearrange the elements to create a "wiggle" pattern where elements alternate between smaller-or-equal and greater-or-equal relationships.

Specifically, reorder the array so that: nums[0] ≤ nums[1] ≥ nums[2] ≤ nums[3] ≥ nums[4]...

The pattern: Each element at an even index should be ≤ its right neighbor, and each element at an odd index should be ≥ its right neighbor. Think of it as creating peaks and valleys!

Input: An integer array with at least one element
Output: The same array rearranged in wiggle sort order
Guarantee: A valid wiggle arrangement always exists for the input.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: One possible wiggle arrangement. The pattern shows: 3≤5≥1≤6≥2≤4, which satisfies the alternating ≤≥≤≥ requirement.

example_2.py — Small Array

$ Input: [6,6,5,6,3,8]

› Output: [6,6,5,6,3,8]

💡 Note: With duplicates, the original array might already be valid: 6≤6≥5≤6≥3≤8. Notice that equal values (≤ and ≥) satisfy both conditions.

example_3.py — Two Elements

$ Input: [2,1]

› Output: [1,2]

💡 Note: For a two-element array, we need nums[0] ≤ nums[1], so [1,2] works perfectly as 1≤2.

Visualization

Tap to expand

Understanding the Visualization

Walk the Mountain Range

Start from the left and examine each position

Identify Misplaced Elements

Check if current position violates the peak-valley pattern

Local Correction

Swap with neighbor to fix the violation immediately

Continue Forward

Move to next position, previous fixes remain valid

Key Takeaway

🎯 Key Insight: Local fixes create global solutions! By ensuring each adjacent pair satisfies the wiggle condition, we automatically achieve a perfect mountain range pattern across the entire array.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking and potentially swapping each adjacent pair once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the swapping operation

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 5000
The input array always has a valid wiggle sort arrangement

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24 Apple 18

The optimal solution uses a one-pass greedy approach with O(n) time and O(1) space. The key insight is that we can fix violations locally by swapping adjacent elements. As we iterate through the array, whenever we find that the wiggle condition is violated (even index should be ≤ next, odd index should be ≥ next), we simply swap the current element with its neighbor. This local fix ensures the global wiggle pattern without affecting previously processed positions.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Greedy (Optimal)	O(n)	O(1)	Fix violations locally by swapping adjacent elements in a single pass
Sort + Strategic Placement	O(n log n)	O(n)	Sort the array first, then place elements strategically to create wiggle pattern
Brute Force (Try All Permutations)	O(n!)	O(n)	Generate all possible arrangements and check which one satisfies the wiggle condition

One-Pass Greedy (Optimal) — Algorithm Steps

Iterate through the array from left to right
For each position i, check if the wiggle condition is satisfied
If i is even: nums[i] should be ≤ nums[i+1]. If not, swap them
If i is odd: nums[i] should be ≥ nums[i+1]. If not, swap them
Local swaps ensure global wiggle pattern without affecting previous positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Even Index

At even index i, ensure nums[i] ≤ nums[i+1]

Check Odd Index

At odd index i, ensure nums[i] ≥ nums[i+1]

Swap if Violated

If condition violated, swap nums[i] and nums[i+1]

Code -

solution.c — C

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

void wiggleSort(int* nums, int numsSize) {
    for (int i = 0; i < numsSize - 1; i++) {
        // Check wiggle condition violation
        if ((i % 2 == 0 && nums[i] > nums[i + 1]) ||
            (i % 2 == 1 && nums[i] < nums[i + 1])) {
            // Swap to fix violation
            int temp = nums[i];
            nums[i] = nums[i + 1];
            nums[i + 1] = temp;
        }
    }
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int negative = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c == '-') {
            negative = 1;
            reading = 1;
        } else if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = negative ? -num : num;
            num = 0;
            negative = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = negative ? -num : num;
    
    wiggleSort(nums, size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("%d", nums[i]);
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking and potentially swapping each adjacent pair once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the swapping operation

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 5000
The input array always has a valid wiggle sort arrangement

52.4K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler