Reorganize String - Practice Coding Problems

Reorganize String - Problem

Hash Table String Greedy Sorting Heap (Priority Queue) Counting Medium

Reorganize String - The Character Separation Challenge

Given a string s, your task is to rearrange its characters so that no two adjacent characters are identical. Think of it as organizing a queue where no two people with the same name can stand next to each other!

Goal: Return any valid rearrangement of the string, or return an empty string "" if it's impossible to create such an arrangement.

Key Insight: This problem tests your ability to use greedy algorithms and priority queues to manage character frequencies optimally.

Examples:
• Input: "aab" → Output: "aba"
• Input: "aaab" → Output: "" (impossible)
• Input: "aabbcc" → Output: "abacbc"

Input & Output

example_1.py — Basic case with solution

$ Input: s = "aab"

› Output: "aba"

💡 Note: We have 2 'a's and 1 'b'. We can arrange them as 'aba' where no two adjacent characters are the same. Another valid arrangement would be 'baa' is not valid since 'aa' are adjacent.

example_2.py — Impossible case

$ Input: s = "aaab"

› Output: ""

💡 Note: We have 3 'a's and 1 'b'. Since we have more than half the characters as 'a' (3 out of 4), it's impossible to arrange them without having adjacent 'a's. The maximum frequency allowed is ⌈4/2⌉ = 2.

example_3.py — Multiple characters

$ Input: s = "aabbcc"

› Output: "abcabc"

💡 Note: Each character appears twice. We can arrange them by rotating through different characters: a→b→c→a→b→c. Other valid arrangements include 'ababcc', 'abacbc', etc.

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters only
Key insight: If any character appears more than ⌈n/2⌉ times, reorganization is impossible

Asked in

The optimal solution uses a priority queue (max heap) to efficiently manage character frequencies. The key insight is that we must always place the most frequent available character (that differs from the previous one) to maximize our chances of success. This greedy approach with heap operations gives us O(n log k) time complexity, where k ≤ 26 is the number of unique characters.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue (Max Heap) - Optimal	O(n log k)	O(k)	Use max heap to always get the most frequent character efficiently
Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all possible permutations and check each one for validity
Two-Pass: Count + Greedy Placement	O(n log k)	O(k)	First count character frequencies, then place characters using greedy strategy

Priority Queue (Max Heap) - Optimal — Algorithm Steps

Count the frequency of each character
Check if reorganization is possible (max frequency ≤ ⌈n/2⌉)
Push all characters with their frequencies into a max heap
Build result by repeatedly taking the most frequent available character
Use a cooldown mechanism to prevent adjacent duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Max Heap

Create heap with character frequencies

Pop & Place

Take most frequent char, place in result

Cooldown

Store previous char temporarily to avoid adjacency

Restore

Put previous char back in heap if count > 0

Code -

solution.c — C

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

typedef struct {
    char ch;
    int freq;
} CharFreq;

typedef struct {
    CharFreq* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = malloc(sizeof(MaxHeap));
    heap->data = malloc(capacity * sizeof(CharFreq));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

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

void heapifyUp(MaxHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->data[parent].freq >= heap->data[index].freq) break;
        swap(&heap->data[parent], &heap->data[index]);
        index = parent;
    }
}

void heapifyDown(MaxHeap* heap, int index) {
    while (2 * index + 1 < heap->size) {
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        int maxChild = left;
        if (right < heap->size && heap->data[right].freq > heap->data[left].freq) {
            maxChild = right;
        }
        if (heap->data[index].freq >= heap->data[maxChild].freq) break;
        swap(&heap->data[index], &heap->data[maxChild]);
        index = maxChild;
    }
}

void push(MaxHeap* heap, CharFreq item) {
    heap->data[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

CharFreq pop(MaxHeap* heap) {
    CharFreq result = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    heapifyDown(heap, 0);
    return result;
}

char* reorganizeString(char* s) {
    static char result[1001];
    int len = strlen(s);
    int charCount[26] = {0};
    
    // Count frequencies
    for (int i = 0; i < len; i++) {
        charCount[s[i] - 'a']++;
    }
    
    // Check if possible
    int maxFreq = 0;
    for (int i = 0; i < 26; i++) {
        if (charCount[i] > maxFreq) {
            maxFreq = charCount[i];
        }
    }
    
    if (maxFreq > (len + 1) / 2) {
        strcpy(result, "");
        return result;
    }
    
    // Create heap
    MaxHeap* heap = createHeap(26);
    for (int i = 0; i < 26; i++) {
        if (charCount[i] > 0) {
            CharFreq cf = {'a' + i, charCount[i]};
            push(heap, cf);
        }
    }
    
    int resultLen = 0;
    CharFreq prev = {'#', 0};
    
    while (heap->size > 0) {
        CharFreq curr = pop(heap);
        result[resultLen++] = curr.ch;
        
        if (prev.freq > 0) {
            push(heap, prev);
        }
        
        prev.ch = curr.ch;
        prev.freq = curr.freq - 1;
    }
    
    result[resultLen] = '\0';
    free(heap->data);
    free(heap);
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        memmove(s, start, strlen(start) + 1);
    }
    
    printf("\"%s\"", reorganizeString(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

O(n) for counting, O(k log k) for heap operations where k ≤ 26 unique characters, O(n log k) for building result

⚡ Linearithmic

Space Complexity

O(k)

Space for frequency map and heap storing at most k unique characters

✓ Linear 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