Skip to content

Latest commit

 

History

History
166 lines (127 loc) · 3.81 KB

57.sort-characters-by-frequency.md

File metadata and controls

166 lines (127 loc) · 3.81 KB
Raw

451. 根据字符出现频率排序

https://leetcode-cn.com/problems/sort-characters-by-frequency/

题目描述

给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
"tree"

输出:
"eert"

解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。
示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

解释:
'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。
示例 3:

输入:
"Aabb"

输出:
"bbAa"

解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-characters-by-frequency
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法1：哈希表+堆

思路

  • 用哈希表来记录每个字符的出现次数
  • 以字符出现次数建立一个大顶堆
  • 一边弹出堆顶，一边构建新的字符串

复杂度分析

  • 时间复杂度：$O(n+klogk)$，n 是字符串的长度，k 是字符串中字符集的大小。
  • 空间复杂度：$O(k)$，k 是字符串中字符集的大小，堆的大小。

代码

JavaScript Code

/**
 * @param {string} s
 * @return {string}
 */
var frequencySort = function (s) {
    const map = {}

    for (let i = 0; i < s.length; i++) {
        const c = s[i];
        map[c] = (map[c] || 0) + 1
    }

    // 堆的数据结构 [char, count]
    const list = Object.keys(map).map(c => [c, map[c]])
    const heap = new MaxHeap(list, function comparator(inserted, compared) {
        return inserted[1] < compared[1];
    });

    let str = ''
    while (heap.size() > 0) {
        const [char, cnt] = heap.pop();
        str += char.repeat(cnt)
    }
    return str
};

// **************************************************

class Heap {
    constructor(list = [], comparator) {
        this.list = list;
        this.comparator = comparator;

        this.init();
    }

    init() {
        const size = this.size();
        for (let i = Math.floor(size / 2) - 1; i >= 0; i--) {
            this.heapify(this.list, size, i);
        }
    }

    insert(n) {
        this.list.push(n);
        const size = this.size();
        for (let i = Math.floor(size / 2) - 1; i >= 0; i--) {
            this.heapify(this.list, size, i);
        }
    }

    peek() {
        return this.list[0];
    }

    pop() {
        const last = this.list.pop();
        if (this.size() === 0) return last;
        const returnItem = this.list[0];
        this.list[0] = last;
        this.heapify(this.list, this.size(), 0);
        return returnItem;
    }

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

class MaxHeap extends Heap {
    constructor(list, comparator) {
        super(list, comparator);
    }

    heapify(arr, size, i) {
        let largest = i;
        const left = Math.floor(i * 2 + 1);
        const right = Math.floor(i * 2 + 2);

        if (left < size && this.comparator(arr[largest], arr[left]))
            largest = left;
        if (right < size && this.comparator(arr[largest], arr[right]))
            largest = right;

        if (largest !== i) {
            [arr[largest], arr[i]] = [arr[i], arr[largest]];
            this.heapify(arr, size, largest);
        }
    }
}

更多题解可以访问：https://github.com/suukii/91-days-algorithm