2.5.8标准输入读取字符按频率排序输出(自定义结构体排序)

解题思路
由于是要从标准输入中读取，并按照单词出现的频率排序，因此我们可以按照如下方式去做。

• 将读入的单词放到一个数组中
• 对这个数组进行排序
• 计算每个单词出现的次数
• 定义一个结构体，来存储单词和单词出现的次数
• 按照自定义结构体进行排序
• 输出
  为什么要定义一个结构体？
  很简单，之所以定义结构体来存储单词和出现的频率是因为仿照MAP容器，每一个单词对应一个单词出现的频率，因此我们能够精确的确定单词和频率之间测对应关系；

对自定义结构体进行排序
利用STL算法库中的sort()函数,sort()函数的前两个参数为开始和结束的迭代器，第三个参数为返回值为true的比较情况。因此，如果我们要想对自己自定义的结构体排序就需要用到第三个参数。
或者说我们在结构体中重载<或者>运算符，返回值为bool，这样sort()才能有比较的标准。
注意：重载<>这两个运算符时可以在类内实现，但是自定义比较函数必须得是全局函数，不能在类内实现，如果实在向在类内定义比较函数，则必须将该比较函数定义为静态函数，即该类的所有对象共享一个！（函数前加static）

//frequency_namespace.h
#include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <array>
#include <algorithm>

using std::array;
using std::cin;
using std::cout;
using std::endl;
using std::queue;
using std::string;
using std::vector;

//从标准输入中读取一列字符串并按照字符出现频率由高到低打印粗每个字符串即出现次数

#include "frequency_namespace.h"
struct record
{
    string str;
    int freq;
};

bool a_less_b(const record &r, const record &s)
{
    return r.freq < s.freq;
}
bool a_greater_b(const record &r, const record &s)
{
    return r.freq > s.freq;
}
class Frequency
{
public:
    Frequency() {}
    ~Frequency() {}

public:
    void Freq()
    {
        vector<string> str;
        //输入数据
        string str_temp;
        while (cin >> str_temp && str_temp != "#")
        {
            str.push_back(str_temp);
        }
        sort(str.begin(), str.end());
        //计算频率并排序
        int nCount = 0;
        record r1;
        r1.freq = 1;

        while (nCount < str.size() - 1)
        {
            if (str[nCount] != str[nCount + 1])
            {
                r1.str = str[nCount];
                strNum.push_back(r1);
                r1.freq = 0;
            }
            r1.freq++;
            nCount++;
        }
        //最后一个添加进数组
        r1.str = str[nCount];
        strNum.push_back(r1);
        sort(strNum.begin(), strNum.end(), a_greater_b);
    }
    void Print()
    {
        for (int i = 0; i < strNum.size(); i++)
        {
            for (int j = 0; j < strNum[i].freq; j++)
                cout << strNum[i].str << " ";
        }
        cout << endl;
    }

private:
    vector<record> strNum;
};

//类内重载> <运算符

//从标准输入中读取一列字符串并按照字符出现频率由高到低打印粗每个字符串即出现次数

#include "frequency_namespace.h"

class Frequency
{
public:
    Frequency() {}
    ~Frequency() {}

private:
    struct record
    {
        string str;
        int freq;
        bool operator<(const record &a) const //这两个重载的运算符可以定义在类里，而全局函数则不可以定义在类里
        {
            return freq < a.freq;
        }
        bool operator>(const record &a) const
        {
            return freq > a.freq;
        }
    };

    // static bool a_less_b(const record &r, const record &s)
    // {
    //     return r.freq < s.freq;
    // }
    // static bool a_greater_b(const record &r, const record &s)
    // {
    //     return r.freq > s.freq;
    // }

public:
    void Freq()
    {
        vector<string> str;
        //输入数据
        string str_temp;
        while (cin >> str_temp && str_temp != "#")
        {
            str.push_back(str_temp);
        }
        sort(str.begin(), str.end());
        //计算频率并排序
        int nCount = 0;
        record r1;
        r1.freq = 1;

        while (nCount < str.size() - 1)
        {
            if (str[nCount] != str[nCount + 1])
            {
                r1.str = str[nCount];
                strNum.push_back(r1);
                r1.freq = 0;
            }
            r1.freq++;
            nCount++;
        }
        //最后一个添加进数组
        r1.str = str[nCount];
        strNum.push_back(r1);
        sort(strNum.begin(), strNum.end());
    }
    void Print()
    {
        for (int i = 0; i < strNum.size(); i++)
        {
            for (int j = 0; j < strNum[i].freq; j++)
                cout << strNum[i].str << " ";
        }
        cout << endl;
    }

private:
    vector<record> strNum;
};