C++map容器的排序

[wasd6081058]

大家好，我定义了一个map<string, int> 容器，用来记录文章中每个单词出现的个数，现在想按单词个数从大到小输出，请问如何对map容器进行排序呢？下面是我的程序，大家看看有啥问题，如果还有其他方法的话额外加分

#include <map>
#include <string>
#include <iostream>
#include <algorithm>

using namespace std;
typedef map<string,int>::value_type type;
bool comp(map<string,int>::value_type s1,map<string,int>::value_type s2)
{
return s1.second > s2.second;
}
int main()
{
map<string,int> m;
m.insert(type("zhang",2));
m.insert(type("aa",5));
m.insert(type("bb",4));
m.insert(type("cc",3));
//sort(m.begin(),m.end(),comp);
map<string,int>::iterator index;
for(index = m.begin(); index != m.end(); ++index){
cout << index->first << " " << index->second << endl;
}
return 0;
}

[healer_kx]

你应该再用个vector啥的，把map的内容导入vector，然后排序，我暂时想不到更好的办法。

[stereoMatching]

我想到一个笨方法，建立两个map，一个是map<string,int>，一个是map<int，string>
如果担心string构建的代价,可以请shared_ptr解决
map<std::shared_ptr<string>,int>, map<int, std::shared_ptr<string> >

如果是我的话

#ifndef HELP_00_HPP
#define HELP_00_HPP

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <utility>

template<typename BiFunc>
class sort_pair_first
{
public:
    typedef bool result_type;

    template<typename T>
    bool operator()(T const &lhs, T const &rhs) const
    {
      return BiFunc()(lhs.first, rhs.first);
      //return lhs.first < rhs.first;
    }
};

template<typename BiFunc>
class sort_pair_second
{
public:
    typedef bool result_type;

    template<typename T>
    bool operator()(T const &lhs, T const &rhs) const
    {
      return BiFunc()(lhs.second, rhs.second);
    }
};

class dictionaryManager
{
public:
    dictionaryManager() {}

    void add_data(std::pair<std::string, size_t> const &data)
    {
        dic_array_.push_back(data);
    }

    void add_and_sort_by_occur_time(std::pair<std::string, size_t> const &data)
    {
        add_data(data);
        sort_by_occur_time();
    }

    void add_and_sort_by_word(std::pair<std::string, size_t> const &data)
    {
        add_data(data);
        sort_by_word();
    }

    void print_data()
    {
        std::for_each(std::begin(dic_array_), std::end(dic_array_),
        [](std::pair<std::string, size_t> const &data)
        {
           std::cout << data.first << ", " << data.second<<std::endl;
        });
    }

    void sort_by_occur_time()
    {
        std::sort(std::begin(dic_array_), std::end(dic_array_),
                  sort_pair_second<std::less<size_t> >() );
    }

    void sort_by_word()
    {
        std::sort(std::begin(dic_array_), std::end(dic_array_),
                 sort_pair_first<std::less<std::string> >() );
    }

private:
    dictionaryManager(dictionaryManager const&);
    dictionaryManager& operator=(dictionaryManager const&);

private:
    std::vector<std::pair<std::string, size_t> > dic_array_;
};

inline void test_dictionary()
{
    dictionaryManager manager;
    manager.add_and_sort_by_word(std::make_pair("haha", 3) );
    manager.add_and_sort_by_word(std::make_pair("aa", 3) );
    manager.print_data();
}

#endif // HELP_00_HPP

std::pair可视情况需要换成自己定义的物件

[stereoMatching]

做了一些优化（加入rvalue referece的overload）
vc2010可执行，因为懒的关系我直接使用std::pair
若需考虑到可扩充性，建议楼主自己定制一个资料结构共vector储存

#ifndef HELP_00_HPP
#define HELP_00_HPP

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <utility>

template<typename BiFunc>
class sort_pair_first
{
public:
    typedef bool result_type;

    template<typename T>
    bool operator()(T const &lhs, T const &rhs) const
    {
      return BiFunc()(lhs.first, rhs.first);
    }
};

template<typename BiFunc>
class sort_pair_second
{
public:
    typedef bool result_type;

    template<typename T>
    bool operator()(T const &lhs, T const &rhs) const
    {
      return BiFunc()(lhs.second, rhs.second);
    }
};

class dictionaryManager
{
public:
    dictionaryManager() {}

    void add_data(std::pair<std::string, size_t> const &data)
    {
        dic_array_.push_back(data);
    }

    void add_data(std::pair<std::string, size_t> &&data)
    {
        dic_array_.push_back(std::move(data) );
    }

    void add_and_sort_by_occur_time(std::pair<std::string, size_t> const &data)
    {
        add_data(data);
        sort_by_occur_time();
    }

    void add_and_sort_by_word(std::pair<std::string, size_t> const &data)
    {
        add_data(data);
        sort_by_word();
    }

    void add_and_sort_by_occur_time(std::pair<std::string, size_t> &&data)
    {
        add_data(std::move(data) );
        sort_by_occur_time();
    }

    void add_and_sort_by_word(std::pair<std::string, size_t> &&data)
    {
        add_data(std::move(data) );
        sort_by_word();
    }

    void print_data() const
    {
        std::for_each(std::begin(dic_array_), std::end(dic_array_),
        [](std::pair<std::string, size_t> const &data)
        {
           std::cout << data.first << ", " << data.second<<std::endl;
        });
    }

    void sort_by_occur_time()
    {
        std::sort(std::begin(dic_array_), std::end(dic_array_),
                  sort_pair_second<std::less<size_t> >() );
    }

    void sort_by_word()
    {
        std::sort(std::begin(dic_array_), std::end(dic_array_),
                 sort_pair_first<std::less<std::string> >() );
    }

private:
    dictionaryManager(dictionaryManager const&);
    dictionaryManager& operator=(dictionaryManager const&);

private:
    std::vector<std::pair<std::string, size_t> > dic_array_;
};

inline void test_dictionary()
{
    dictionaryManager manager;
    manager.add_and_sort_by_word(std::make_pair("haha", 3) );
    manager.add_and_sort_by_word(std::make_pair("aa", 3) );
    manager.print_data();
}

#endif // HELP_00_HPP

[taodm]

楼主，你可能对map究竟是啥东西还没搞清楚吧。
当然是再用一个 map 或者 vector+排序