Rearrange characters in a String such that no two adjacent characters are same

//Driver Code Starts
// JavaScript program to rearrange characters in a string
// so that no two adjacent characters are the same.

class MaxHeap {
    constructor() {
        this.heap = [];
    }

    size() {
        return this.heap.length;
    }

    isEmpty() {
        return this.size() === 0;
    }

    insert(count, char) {
        this.heap.push([count, char]);
        this.heapifyUp();
    }

    extractMax() {
        if (this.isEmpty()) return null;
        const max = this.heap[0];
        const last = this.heap.pop();
        if (!this.isEmpty()) {
            this.heap[0] = last;
            this.heapifyDown();
        }
        return max;
    }

    heapifyUp() {
        let index = this.size() - 1;
        while (index > 0) {
            let parentIndex = Math.floor((index - 1) / 2);
            if (this.heap[parentIndex][0] >= this.heap[index][0]) break;
            [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
            index = parentIndex;
        }
    }

    heapifyDown() {
        let index = 0;
        while (2 * index + 1 < this.size()) {
            let leftChild = 2 * index + 1;
            let rightChild = 2 * index + 2;
            let largest = leftChild;
            if (rightChild < this.size() && this.heap[rightChild][0] > this.heap[leftChild][0]) {
                largest = rightChild;
            }
            if (this.heap[index][0] >= this.heap[largest][0]) break;
            [this.heap[index], this.heap[largest]] = [this.heap[largest], this.heap[index]];
            index = largest;
        }
    }
}
//Driver Code Ends

// Function to rearrange characters in a string
// so that no two adjacent characters are the same
function rearrangeString(s) {
    let n = s.length;

    // Store frequencies of all characters in string
    let freq = {};
    for (let char of s) {
        freq[char] = (freq[char] || 0) + 1;
    }

    // Insert all characters with their frequencies into a max heap
    let pq = new MaxHeap();
    for (let [char, count] of Object.entries(freq)) {
        pq.insert(count, char);
    }

    let res = [];
    let prev = [0, ''];

    while (!pq.isEmpty()) {
        // Extract the character with the highest frequency
        let [count, char] = pq.extractMax();
        res.push(char);

        // If the previous character still has a remaining count, reinsert it
        if (prev[0] > 0) {
            pq.insert(prev[0], prev[1]);
        }

        // Update previous character with decremented frequency
        prev = [count - 1, char];
    }

    // If length of the resultant string and original string is not the same, return ""
    return res.length === n ? res.join('') : "";
}

// Driver Code
const s = "aaabc";
console.log(rearrangeString(s));

// JavaScript program to rearrange characters in a string
// so that no two adjacent characters are same.

// Function to rearrange character of a string
// so that no two adjacent characters are same
function rearrangeString(s) {
    const n = s.length;
    let mxCnt = 0;
    let ch = '#';

    // Store frequencies of all characters in string
    let freq = {};
    for (let i = 0; i < n; i++) {
        if (freq[s[i]] === undefined) 
            freq[s[i]] = 0;
            
        freq[s[i]] = freq[s[i]] + 1;
        if (freq[s[i]] > mxCnt) {
            mxCnt = freq[s[i]];
            ch = s[i];
        }
    }

    // Check if the result is possible or not
    if (mxCnt > Math.ceil(n / 2)) return "";

    // Filling the most frequently occurring char at
    // even indices
    let ind = 0;
    let res = new Array(n);
    while (mxCnt > 0) {
        res[ind] = ch;
        ind += 2;
        mxCnt--;
    }
    freq[ch] = 0;
    
    // Filling rest of the characters first at even positions,
    // then odd positions using for loop for (a-z):
    for (let i = 97; i <= 122; i++) {
        let c = String.fromCharCode(i);
        
        // Skip if the character isn't in the string
        if (freq[c] === undefined) continue; 
        
        let cnt = freq[c];
        while (cnt > 0) {
            
            // Switch to odd, when all even positions were filled
            ind = (ind >= n) ? 1 : ind;
            res[ind] = c;
            ind += 2;
            cnt--;
        }
    }
    
    return res.join('');
}

// Driver Code
let s = "aaabc";
console.log(rearrangeString(s));