Wiggle Sort II - Practice Coding Problems

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.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) to generate all permutations, O(n) to check each permutation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing one permutation at a time during generation

⚡ Linearithmic Space

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
✓ 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	O(n)	O(n)	Use quickselect to find median, then place elements optimally without full sorting

Brute Force (Try All Permutations) — Algorithm Steps

Generate all n! permutations of the input array
For each permutation, check if it satisfies the wiggle condition
Return the first valid permutation found
Wiggle condition: nums[0] < nums[1] > nums[2] < nums[3]...

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a new arrangement of the array elements

Check Wiggle Pattern

Verify if current arrangement satisfies alternating < > < > pattern

Continue or Return

If valid wiggle found, return; otherwise try next permutation

Code -

solution.c — C

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

bool isWiggle(int* arr, int size) {
    for (int i = 0; i < size - 1; i++) {
        if (i % 2 == 0) {
            if (arr[i] >= arr[i + 1]) return false;
        } else {
            if (arr[i] <= arr[i + 1]) return false;
        }
    }
    return true;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool nextPermutation(int* nums, int size) {
    int i = size - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) i--;
    if (i < 0) return false;
    
    int j = size - 1;
    while (nums[j] <= nums[i]) j--;
    swap(&nums[i], &nums[j]);
    
    int left = i + 1, right = size - 1;
    while (left < right) {
        swap(&nums[left], &nums[right]);
        left++;
        right--;
    }
    return true;
}

void wiggleSort(int* nums, int size) {
    // Sort first
    for (int i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
            if (nums[i] > nums[j]) {
                swap(&nums[i], &nums[j]);
            }
        }
    }
    
    do {
        if (isWiggle(nums, size)) {
            return;
        }
    } while (nextPermutation(nums, size));
}

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! × n)

O(n!) to generate all permutations, O(n) to check each permutation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing one permutation at a time during generation

⚡ Linearithmic Space

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

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

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler