Leetcode 451:根据字符出现频率排序（最详细解决方案！！！）

115 阅读 0 评论 76 点赞

我是靠谱客的博主自由口红，这篇文章主要介绍Leetcode 451:根据字符出现频率排序（最详细解决方案！！！），现在分享给大家，希望可以做个参考。

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

示例 1:

复制代码

1
2
3
4
5
6
7
8
9
10
输入:
"tree"

输出:
"eert"

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

示例 2:

复制代码

1
2
3
4
5
6
7
8
9
10
输入:
"cccaaa"

输出:
"cccaaa"

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

示例 3:

复制代码

1
2
3
4
5
6
7
8
9
10
输入:
"Aabb"

输出:
"bbAa"

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

解题思路

我们首先想到的解题思路是通过一个dict存储所有字符出现的次数，然后根据字符出现的次数排序，最后输出排序结果。

复制代码

1
2
3
4
5
6
7
8
9
class Solution:
    def frequencySort(self, s: str) -> str:
        str_map = collections.defaultdict(int)
        for i in s:
            str_map[i] += 1

        tmp = sorted(str_map.items(), key=lambda d:d[1], reverse=True)
        return ''.join([key*val for key, val in tmp])

我觉得如下这种做法更好

复制代码

1
2
3
4
5
6
7
8
class Solution:
    def frequencySort(self, s: str) -> str:
        str_map = collections.defaultdict(int)
        for i in s:
            str_map[i] += 1

        return ''.join(sorted([i for i in s], key=lambda a: str_map[a], reverse=True))

我们这里给出另外一种写法。

复制代码

1
2
3
4
class Solution:
    def frequencySort(self, s: str) -> str:
        return ''.join(c*-n for n,c in sorted((-s.count(c),c) for c in set(s)))

我们也可以通过一个PriorityQueue解决这个问题。我们首先要实现一个ch类，因为PriorityQueue插入操作的过程中会有比较操作，所以在这个类里面，我们要实现__lt__这个函数。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from queue import PriorityQueue
class ch:
    def __init__(self, key, val):
        self.val = val
        self.key = key
    def __lt__(self, other):
        return self.val > other.val

class Solution:
    def frequencySort(self, s: str) -> str:
        str_map = collections.defaultdict(int)
        for i in s:
            str_map[i] += 1

        qCh = PriorityQueue()
        for key, val in str_map.items():
            if val > 0:
                c = ch(key, val)
                qCh.put(c)

        result = str()
        while not qCh.empty():
            tp = qCh.get()
            result += tp.val*tp.key
        return result

上面这些解法的时间复杂度都是O(nlogn)级别的，那么我们有没有办法优化到O(n)这个级别呢？我们这里有一个很巧妙的解法，利用list的index间接排序。首先还是统计s的元素个数，然后将元素个数作为index，而元素类型作为value存入到list中。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution:
    def frequencySort(self, s: str) -> str:
        if not s:
            return ''

        mem, maxFre = collections.defaultdict(int), float('-inf')
        for c in s:
            mem[c] += 1
            maxFre = max(maxFre, mem[c])

        vec = [''] * (maxFre + 1)
        for key, val in mem.items():
            vec[val] += key*val
        return "".join(vec[::-1])