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

最新推荐文章于 2022-08-15 11:42:39 发布

klbc

最新推荐文章于 2022-08-15 11:42:39 发布

阅读量191

点赞数

分类专栏： LeetCode 文章标签：字符串 leetcode 算法

本文链接：https://blog.csdn.net/u010323563/article/details/113346817

版权

LeetCode 专栏收录该内容

85 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何根据字符出现频率对字符串进行排序。提供了三种不同的解决方案：1) 使用自定义函数对象进行排序；2) 利用双映射进行频率排序；3) 直接使用数组统计和构造结果字符串。每种方法的时间复杂度和实现细节都有所不同。

摘要由CSDN通过智能技术生成

描述

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

示例 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/

求解

    // 自定义函数对象（包含状态，即字符频率），用于字符排序比较函数
    struct charFreCompare {
    public:
        bool operator()(const char c1, const char c2) {
            if (record[c1] != record[c2]) {
                // 出现频率不一致以频率优先
                return record[c1] > record[c2];
            }
            // 出现频率一致以字典序
            return c1 < c2;
        }

        void init(std::string_view s) {
            for (const char &c : s) {
                ++record[c];
            }
        }

    private:
        int record[128]{0}; // 记录每个字符出现的次数
    };

    class Solution {
    public:
        // 方法一，暴力解法，自定义排序函数对象（包含状态，即字符频率），暴力排序
        // 速度最慢52ms
        string frequencySort_1e(string s) {
            charFreCompare cCompare;
            cCompare.init(s); // 函数对象初始化状态，即统计字符频率
            std::sort(s.begin(), s.end(), cCompare);
            return s;
        }

        // 方法二，使用两个map
        // 速度一般 16ms
        string frequencySort_2e(string s) {
            std::map<char, int> record; // <char, charFrequency>
            for (const char c : s) {
                ++record[c];
            }
            std::multimap<int, char> freqCharRec;  // <charFreq, char>，注意，这儿可能存储频率相同的字符，因此需要使用Multimap
            for (const auto &[c, num] : record) {
                freqCharRec.emplace(num, c);
            }
            string res;
            for (auto riter = freqCharRec.crbegin(); riter != freqCharRec.crend(); ++riter) {
                res.append(riter->first, riter->second);
            }
            return res;
        }

        // 方法三，直接使用数组，不使用任何额外其他容器
        // 速度最快 4ms
        string frequencySort(string s) {
            constexpr int N = 128;
            int record[N]{0}; // 记录字符的频率，字符值作为下标
            for (const auto c : s) {
                ++record[c];
            }

            const int len = s.length();
            int index = 0;
            string res;
            while (index < len) {
                int maxCount = 0;
                char maxChar = 'a';
                // 通过遍历数组找到当前频率最大的字符
                for (int i = 0; i < N; ++i) {
                    if (record[i] > maxCount) {
                        maxCount = record[i];
                        maxChar = char(i);
                    }
                }

                // 使用当前频率最大的字符构造字符串
                res.append(maxCount, maxChar);
                record[maxChar] = 0; // 注意，找到当前频率最大的字符后，需要将其频率置位0
                index = res.length();
            }
            return res;
        }
    };