Reorganize String

Reorganize String - Problem

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

Given a string s, rearrange the characters of s so that any two adjacent characters are not the same.

Return any possible rearrangement of s or return "" (empty string) if not possible.

Input & Output

Example 1 — Basic Case

$ Input: s = "aab"

› Output: "aba"

💡 Note: We can rearrange "aab" to "aba" where no two adjacent characters are the same. Another valid answer would be "baa".

Example 2 — Impossible Case

$ Input: s = "aaab"

› Output: ""

💡 Note: We have 3 'a's and 1 'b'. Since 'a' appears more than (4+1)/2 = 2.5 times, it's impossible to arrange without adjacent duplicates.

Example 3 — Single Character

$ Input: s = "a"

› Output: "a"

💡 Note: Single character strings are always valid since there are no adjacent pairs to worry about.

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is that if any character appears more than ⌈n/2⌉ times, rearrangement is impossible. The optimal approach uses a max heap to always select the most frequent available character that won't create adjacent duplicates. Time: O(n log k), Space: O(k) where k is the number of unique characters.

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all possible arrangements of the string characters and check each one to see if adjacent characters are different. Return the first valid arrangement found.

Frequency Count with Greedy Placement

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

Count the frequency of each character, then greedily place the most frequent characters first while ensuring no two adjacent characters are the same.

Priority Queue (Max Heap) Approach

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

Use a priority queue to maintain characters by frequency. Always pick the most frequent character that won't create adjacent duplicates, building the result character by character.

Brute Force - Try All Permutations — Algorithm Steps

Generate all permutations of the input string
For each permutation, check if adjacent characters are different
Return first valid permutation or empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements

Check Validity

Test each arrangement for adjacent duplicates

Return First Valid

Return first valid arrangement found

Code -

solution.c — C

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

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

int isValid(char *s, int len) {
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == s[i + 1]) return 0;
    }
    return 1;
}

int permute(char *s, int start, int len, char *result) {
    if (start == len) {
        if (isValid(s, len)) {
            strcpy(result, s);
            return 1;
        }
        return 0;
    }
    
    for (int i = start; i < len; i++) {
        swap(&s[start], &s[i]);
        if (permute(s, start + 1, len, result)) return 1;
        swap(&s[start], &s[i]);
    }
    return 0;
}

char* solution(char *s) {
    int len = strlen(s);
    if (len <= 1) {
        char *result = malloc((len + 1) * sizeof(char));
        strcpy(result, s);
        return result;
    }
    
    char *copy = malloc((len + 1) * sizeof(char));
    strcpy(copy, s);
    
    char *result = malloc((len + 1) * sizeof(char));
    if (permute(copy, 0, len, result)) {
        free(copy);
        return result;
    }
    
    free(copy);
    strcpy(result, "");
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char *result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

156.0K Views

High Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler