C++排序问题
Set结构体排序：
#include
#include
#include
using namespace std;
struct node
{
char ch;
int cost;
node()
{
ch = '\0';
cost = 0;
}
//把这个函数注释了，对整个程序没有任何影响
bool operator == ( const node &rhs) const
{
return rhs.ch == ch;
}
//如果把这个程序注释了，将会出现一堆的错误，有关STL中的错误，是无法调试、无法修改的
bool operator < (const node &rhs) const
{
return rhs.cost > cost;
}
};
// 虽然我们重定义了==函数，但这是无用的，set只根据<符号来做判断
// 可以看到，set内部根据cost排序了
注意：如果set元素是一个结构体，你最好要设置你的仿函数，不然set一般默认是按第一个字段排序的，而我们的实际情况是想按序号i排序
37 struct ST_Message
38 {
39 public:
40 ST_Message(int seq, int64_t time, string strfrom, string strto, string strinfo){
41 this->seq=seq;this->time=time;this->strfrom=strfrom;this->strto=strto;this->strinfo=strinfo;}
44 int seq;
45 int64_t time;
46 string strfrom;
47 string strto;
48 string strinfo;
49
50 bool operator <(const ST_Message& other) const // 注意是const函数
51 {
52 if (seq != other.seq) // dtime按升序排序
53 {
54 return (seq < other.seq);
55 }
56 else if(time < other.time)
57 {
58 return (time < other.time);
59 }
60 else if(strcmp(strfrom.c_str(), other.strfrom.c_str()) != 0)
61 {
62 return (strcmp(strfrom.c_str(), other.strfrom.c_str()) < 0);
63 }
64 else if(strcmp(strto.c_str(), other.strto.c_str()) != 0)
65 {
66 return (strcmp(strto.c_str(), other.strto.c_str()) < 0);
67 }
68 else
69 {
70 return (strcmp(strinfo.c_str(), other.strinfo.c_str()) < 0);
71 }
72 }
73 };
stl中自动有序的容器map也和set有相同的应用，如果你想快速理解，那么把这篇文章中的set改成map就差不多了。
总之，有序的stl容器在工程中应用什么方便和广泛，但是当我们需要自己的排序的时候，可以用仿函数来设置它!
C++ STL中Map的按Key排序和按Value排序
map是用来存放
但是，我们除了希望能够查询某个学生的成绩，或许还想看看整体的情况。我们想把所有同学和他相应的成绩都输出来，并且按照我们想要的顺序进行输出：比如按照学生姓名的顺序进行输出，或者按照学生成绩的高低进行输出。换句话说，我们希望能够对map进行按Key排序或按Value排序，然后按序输出其键值对的内容。
一、C++ STL中Map的按Key排序
其实，为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。在我们插入
【参考代码】
1. #include
2. #include
3. #include
4. using namespace std;
5.
6. typedef pair
7.
8. ostream& operator<<(ostream& out, const PAIR& p) {
9. return out << p.first << "\t" << p.second;
10. }
11.
12. int main() {
13. map
14. name_score_map["LiMin"] = 90;
15. name_score_map["ZiLinMi"] = 79;
16. name_score_map["BoB"] = 92;
17. name_score_map.insert(make_pair("Bing",99));
18. name_score_map.insert(make_pair("Albert",86));
19. for (map
20. iter != name_score_map.end();
21. ++iter) {
22. cout << *iter << endl;
23. }
24. return 0;
25. }
【运行结果】
大家都知道map是stl里面的一个模板类，现在我们来看下map的定义：
1. template < class Key, class T, class Compare = less
2. class Allocator = allocator
它有四个参数，其中我们比较熟悉的有两个: Key 和 Value。第四个是Allocator，用来定义存储分配模型的，此处我们不作介绍。
现在我们重点看下第三个参数： class Compare = less
这也是一个class类型的，而且提供了默认值less
所谓的函数对象：即调用操作符的类，其对象常称为函数对象（function object），它们是行为类似函数的对象。表现出一个函数的特征，就是通过“对象名+(参数列表)”的方式使用一个 类，其实质是对operator()操作符的重载。
现在我们来看一下less的实现：
1. template <class T> struct less : binary_function
2. bool operator() (const T& x, const T& y) const
3. { return x
4. };
它是一个带模板的struct，里面仅仅对()运算符进行了重载，实现很简单，但用起来很方便，这就是函数对象的优点所在。stl中还为四则运算等常见运算定义了这样的函数对象，与less相对的还有greater：
1. template <class T> struct greater : binary_function
2. bool operator() (const T& x, const T& y) const
3. { return x>y;}
4. };
map这里指定less作为其默认比较函数(对象)，所以我们通常如果不自己指定Compare，map中键值对就会按照Key的less顺序进行组织存储，因此我们就看到了上面代码输出结果是按照学生姓名的字典顺序输出的，即string的less序列。
我们可以在定义map的时候，指定它的第三个参数Compare，比如我们把默认的less指定为greater：
【参考代码】
1. #include
2. #include
3. #include
4. using namespace std;
5.
6. typedef pair
7.
8. ostream& operator<<(ostream& out, const PAIR& p) {
9. return out << p.first << "\t" << p.second;
10. }
11.
12. int main() {
13. map
14. name_score_map["LiMin"] = 90;
15. name_score_map["ZiLinMi"] = 79;
16. name_score_map["BoB"] = 92;
17. name_score_map.insert(make_pair("Bing",99));
18. name_score_map.insert(make_pair("Albert",86));
19. for (map
20. iter != name_score_map.end();
21. ++iter) {
22. cout << *iter << endl;
23. }
24. return 0;
25. }
【运行结果】
现在知道如何为map指定Compare类了，如果我们想自己写一个compare的类，让map按照我们想要的顺序来存储，比如，按照学生姓名的长短排序进行存储，那该怎么做呢？
其实很简单，只要我们自己写一个函数对象，实现想要的逻辑，定义map的时候把Compare指定为我们自己编写的这个就ok啦。
1. struct CmpByKeyLength {
2. bool operator()(const string& k1, const string& k2) {
3. return k1.length() < k2.length();
4. }
5. };
是不是很简单！这里我们不用把它定义为模板，直接指定它的参数为string类型就可以了。
【参考代码】
1. int main() {
2. map
3. name_score_map["LiMin"] = 90;
4. name_score_map["ZiLinMi"] = 79;
5. name_score_map["BoB"] = 92;
6. name_score_map.insert(make_pair("Bing",99));
7. name_score_map.insert(make_pair("Albert",86));
8. for (map
9. iter != name_score_map.end();
10. ++iter) {
11. cout << *iter << endl;
12. }
13. return 0;
14. }
【运行结果】
二、C++ STL中Map的按Value排序
在第一部分中，我们借助map提供的参数接口，为它指定相应Compare类，就可以实现对map按Key排序，是在创建map并不断的向其中添加元素的过程中就会完成排序。
现在我们想要从map中得到学生按成绩的从低到高的次序输出，该如何实现呢？换句话说，该如何实现Map的按Value排序呢？
第一反应是利用stl中提供的sort算法实现，这个想法是好的，不幸的是，sort算法有个限制，利用sort算法只能对序列容器进行排序，就是线性的（如vector，list，deque）。map也是一个集合容器，它里面存储的元素是pair，但是它不是线性存储的（前面提过，像红黑树），所以利用sort不能直接和map结合进行排序。
虽然不能直接用sort对map进行排序，那么我们可不可以迂回一下，把map中的元素放到序列容器（如vector）中，然后再对这些元素进行排序呢？这个想法看似是可行的。要对序列容器中的元素进行排序，也有个必要条件：就是容器中的元素必须是可比较的，也就是实现了<操作的。那么我们现在就来看下map中的元素满足这个条件么？
我们知道map中的元素类型为pair，具体定义如下：
1. template <class T1, class T2> struct pair
2. {
3. typedef T1 first_type;
4. typedef T2 second_type;
5.
6. T1 first;
7. T2 second;
8. pair() : first(T1()), second(T2()) {}
9. pair(const T1& x, const T2& y) : first(x), second(y) {}
10. template <class U, class V>
11. pair (const pair
12. }
pair也是一个模板类，这样就实现了良好的通用性。它仅有两个数据成员first和 second，即key 和 value，而且
在
1. template<class _T1, class _T2>
2. inline bool
3. operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
4. { return __x.first < __y.first
5. || (!(__y.first < __x.first) && __x.second < __y.second); }
重点看下其实现：
1. __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second)
这个less在两种情况下返回true，第一种情况：__x.first < __y.first 这个好理解，就是比较key，如果__x的key小于 __y的key则返回true。
第二种情况有点费解： !(__y.first < __x.first) && __x.second < __y.second
当然由于||运算具有短路作用，即当前面的条件不满足是，才进行第二种情况的判断 。第一种情况__x.first < __y.first不成立，即__x.first >= __y.first成立，在这个条件下，我们来分析下 !(__y.first < __x.first) && __x.second < __y.second
!(__y.first < __x.first) ，看清出，这里是y的key不小于x的key，结合前提条件，__x.first < __y.first不成立，即x的key不小于y的key
即： !(__y.first < __x.first) && !(__x.first < __y.first ) 等价于 __x.first == __y.first ,也就是说，第二种情况是在key相等的情况下，比较两者的value（second）。
这里比较令人费解的地方就是，为什么不直接写 __x.first == __y.first呢？ 这么写看似费解，但其实也不无道理：前面讲过，作为map的key必须实现<操作符的重载，但是并不保证==符也被重载了，如果key没有提供==，那么 ，__x.first == __y.first 这样写就错了。由此可见，stl中的代码是相当严谨的，值得我们好好研读。
现在我们知道了pair类重载了<符，但是它并不是按照value进行比较的，而是先对key进行比较，key相等时候才对value进行比较。显然不能满足我们按value进行排序的要求。
而且，既然pair已经重载了<符，而且我们不能修改其实现，又不能在外部重复实现重载<符。
1. typedef pair
2. bool operator< (const PAIR& lhs, const PAIR& rhs) {
3. return lhs.second < rhs.second;
4. }
如果pair类本身没有重载<符，那么我们按照上面的代码重载<符，是可以实现对pair的按value比较的。现在这样做不行了，甚至会出错（编译器不同，严格的就报错）。
那么我们如何实现对pair按value进行比较呢？ 第一种：是最原始的方法，写一个比较函数； 第二种：刚才用到了，写一个函数对象。这两种方式实现起来都比较简单。
1. typedef pair
2. bool cmp_by_value(const PAIR& lhs, const PAIR& rhs) {
3. return lhs.second < rhs.second; }
4. struct CmpByValue {
5. bool operator()(const PAIR& lhs, const PAIR& rhs) {
6. return lhs.second < rhs.second;
7. } };
接下来，我们看下sort算法，是不是也像map一样，可以让我们自己指定元素间如何进行比较呢？
1. template <class RandomAccessIterator>
2. void sort ( RandomAccessIterator first, RandomAccessIterator last );
3.
4. template <class RandomAccessIterator, class Compare>
5. void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );
我们看到，令人兴奋的是，sort算法和map一样，也可以让我们指定元素间如何进行比较，即指定Compare。需要注意的是，map是在定义时指定的，所以传参的时候直接传入函数对象的类名，就像指定key和value时指定的类型名一样；sort算法是在调用时指定的，需要传入一个对象，当然这个也简单，类名()就会调用构造函数生成对象。
这里也可以传入一个函数指针，就是把上面说的第一种方法的函数名传过来。（应该是存在函数指针到函数对象的转换，或者两者调用形式上是一致的，具体确切原因还不明白，希望知道的朋友给讲下，先谢谢了。）
【参考代码】
1. int main() {
2. map
3. name_score_map["LiMin"] = 90;
4. name_score_map["ZiLinMi"] = 79;
5. name_score_map["BoB"] = 92;
6. name_score_map.insert(make_pair("Bing",99));
7. name_score_map.insert(make_pair("Albert",86));
8. //把map中元素转存到vector中
9. vector
10. sort(name_score_vec.begin(), name_score_vec.end(), CmpByValue());
11. // sort(name_score_vec.begin(), name_score_vec.end(), cmp_by_value);
12. for (int i = 0; i != name_score_vec.size(); ++i) {
13. cout << name_score_vec[i] << endl;
14. }
15. return 0;
16. }
list
1.list的成员函数push_back()把一个对象放到一个list的后面，而 push_front()把对象放到前面
2.list容器不支持在iterator加一个数来指向隔一个的对象。 就是说，我们不能用Milkshakes.begin()+2来指向list中的第三个对象，因为STL的list是以双链的list来实现的， 它不支持随机存取。vector和deque(向量和双端队列)和一些其他的STL的容器可以支持随机存取
3.使用STL list和 iterator，我们要初始化、比较和给iterator增量来遍历这个容器。STL通用的for_each算法能够减轻我们的工作.for_each算法引用了iterator范围的概念，这是一个由起始iterator和一个末尾iterator指出的范围。 起始iterator指出操作由哪里开始，末尾iterator指明到哪结束，但是它不包括在这个范围内。
4.使用iterator范围时，这个范围指出一个list或任意 其他容器中的一部分来处理。通常首iterator指着开始的位置，次iterator指着停止处理的地方。 由次iterator指出的元素不被处理。
5.在STL中有时容器支持它自己对一个特殊算法的实现，这通常是为了提高性能。list容器有它自己的sort算法，这是因为通用算法仅能为那些提供随机存取里面元素 的容器排序，而由于list是作为一个连接的链表实现的，它不支持对它里面的元素随机存取。所以就需要一个特殊的 sort()成员函数来排序list。
由于各种原因，容器在性能需要较高或有特殊效果需求的场合支持外部函数(extra functions)， 这通过利用构造函数的结构特性可以作到。
6.必须确保在两个尖括号之间或尖括号和名字之间用空格隔开，因为是为了避免同“>>”移位运算符混淆。比如
vector
这样写会报错，而这样写：
vector > veclis;
就可以避免错误
7.vector（向量）——STL中标准而安全的数组。只能在vector的“前面”增加数据。
deque（双端队列double-ended queue）——在功能上和vector相似，但是可以在前后两端向其中添加数据。
list（列表）——游标一次只可以移动一步。如果你对链表已经很熟悉，那么STL中的list则是一个双向链表（每个节点有指向前驱和指向后继的两个指针）。
set（集合）——包含了经过排序了的数据，这些数据的值(value)必须是唯一的。
map（映射）——经过排序了的二元组的集合，map中的每个元素都是由两个值组成，其中的key（键值，一个map中的键值必须是唯一的）是在排序或搜索时使用，它的值可以在容器中重新获取；而另一个值是该元素关联的数值。比如，除了可以ar[43] = "overripe"这样找到一个数据，map还可以通过ar["banana"] = "overripe"这样的方法找到一个数据。如果你想获得其中的元素信息，通过输入元素的全名就可以轻松实现。
multiset（多重集）——和集合（set）相似，然而其中的值不要求必须是唯一的（即可以有重复）。
multimap（多重映射）——和映射（map）相似，然而其中的键值不要求必须是唯一的（即可以有重复）。
8.游标是指针，但不仅仅是指针。游标和指针很像，功能很像指针，但是实际上，游标是通过重载一元的”*”和”->”来从容器中间接地返回一个值。
9.iterator——对于除了vector以外的其他任何容器，你可以通过这种游标在一次操作中在容器中朝向前的方向走一步。这意味着对于这种游标你只能使用“++”操作符。而不能使用“--”或“+=”操作符。而对于vector这一种容器，你可以使用“+=”、“—”、“++”、“-=”中的任何一种操作符和“<”、“<=”、“>”、“>=”、“==”、“!=”等比较运算符。
10.除了类型和值外，模板含有其他的参数。你可以传递一个回调函数（通常所说的声明“predicate”——这是带有一个参数的函数返回一个布尔值）。例如，如果你想自动建立一个集合，集合中的元素按升序排列，你可以用简明的方法建立一个set类：
set
greater 是另一个模板函数（范型函数），当值放置在容器中后，它用来为这些值排序。如果你想按降序排列这些值，你可以这样写：
set
11.vector中reserve只是预先划分一块内存给vector使用，主要是为了提高效率：避免在不断push_back的过程中，由于容量变动导致的重新分配！
如果没有的话，push_back的之后，当内存不够了，就会有内存的重新分配和元素的拷贝。这是绝对很低效的。
如果 vector的容量不够了，它会
1. 重新分配更多的空间（一般是增加 N/2，N为原容量）
2. 将现有vector中的数据逐个拷贝到新空间
3. 释放旧空间中的所有元素
4. vector 指向新空间