C++排序问题

Set结构体排序:

#include <iostream>

#include <vector>

#include <set>

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是用来存放<key, value>键值对的数据结构,可以很方便快速的根据key查到相应的value。假如存储学生和其成绩(假定不存在重名,当然可以对重名加以区分),我们用map来进行存储就是个不错的选择。 我们这样定义,map<string, int>,其中学生姓名用string类型,作为Key;该学生的成绩用int类型,作为value。这样一来,我们可以根据学生姓名快速的查找到他的成绩。

        但是,我们除了希望能够查询某个学生的成绩,或许还想看看整体的情况。我们想把所有同学和他相应的成绩都输出来,并且按照我们想要的顺序进行输出:比如按照学生姓名的顺序进行输出,或者按照学生成绩的高低进行输出。换句话说,我们希望能够对map进行按Key排序或按Value排序,然后按序输出其键值对的内容。

一、C++ STLMap的按Key排序

       其实,为了实现快速查找,map内部本身就是按序存储的(比如红黑树)。在我们插入<key, value>键值对时,就会按照key的大小顺序进行存储。这也是作为key的类型必须能够进行<运算比较的原因。现在我们用string类型作为key,因此,我们的存储就是按学生姓名的字典排序储存的。

【参考代码】

1. #include<map>  

2. #include<string>  

3. #include<iostream>  

4. using namespace std;  

5.   

6. typedef pair<string, int> 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<string, int> name_score_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<string, int>::iterator iter = name_score_map.begin();  

20.        iter != name_score_map.end();  

21.        ++iter) {  

22.     cout << *iter << endl;  

23.   }  

24.   return 0;  

25.  }  

【运行结果】

 

大家都知道mapstl里面的一个模板类,现在我们来看下map的定义:

1. template < class Key, class T, class Compare = less<Key>,  

2.            class Allocator = allocator<pair<const Key,T> > > class map;  


它有四个参数,其中我们比较熟悉的有两个: Key Value。第四个是Allocator,用来定义存储分配模型的,此处我们不作介绍。

现在我们重点看下第三个参数: class Compare = less<Key> 

这也是一个class类型的,而且提供了默认值less<Key>lessstl里面的一个函数对象,那么什么是函数对象呢?

所谓的函数对象:即调用操作符的类,其对象常称为函数对象(function object),它们是行为类似函数的对象。表现出一个函数的特征,就是通过对象名+(参数列表)”的方式使用一个 类,其实质是对operator()操作符的重载。

现在我们来看一下less的实现:

1. template <class T> struct less : binary_function <T,T,bool> {  

2.   bool operator() (const T& x, const T& y) const  

3.     {return x<y;}  

4. };  


它是一个带模板的struct,里面仅仅对()运算符进行了重载,实现很简单,但用起来很方便,这就是函数对象的优点所在。stl中还为四则运算等常见运算定义了这样的函数对象,与less相对的还有greater

1. template <class T> struct greater : binary_function <T,T,bool> {  

2.   bool operator() (const T& x, const T& y) const  

3.     {return x>y;}  

4. };  


map这里指定less作为其默认比较函数(对象),所以我们通常如果不自己指定Comparemap中键值对就会按照Keyless顺序进行组织存储,因此我们就看到了上面代码输出结果是按照学生姓名的字典顺序输出的,即stringless序列。

我们可以在定义map的时候,指定它的第三个参数Compare,比如我们把默认的less指定为greater

【参考代码】

1. #include<map>  

2. #include<string>  

3. #include<iostream>  

4. using namespace std;  

5.   

6. typedef pair<string, int> 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<string, int, greater<string> > name_score_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<string, int>::iterator iter = name_score_map.begin();  

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<string, int, CmpByKeyLength> name_score_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<string, int>::iterator iter = name_score_map.begin();  

9.        iter != name_score_map.end();  

10.        ++iter) {  

11.     cout << *iter << endl;  

12.   }  

13.   return 0;  

14. }  

【运行结果】

 

二、C++ STLMap的按Value排序

        在第一部分中,我们借助map提供的参数接口,为它指定相应Compare类,就可以实现对mapKey排序,是在创建map并不断的向其中添加元素的过程中就会完成排序。

现在我们想要从map中得到学生按成绩的从低到高的次序输出,该如何实现呢?换句话说,该如何实现Map的按Value排序呢?

        第一反应是利用stl中提供的sort算法实现,这个想法是好的,不幸的是,sort算法有个限制,利用sort算法只能对序列容器进行排序,就是线性的(如vectorlistdeque)。map也是一个集合容器,它里面存储的元素是pair,但是它不是线性存储的(前面提过,像红黑树),所以利用sort不能直接和map结合进行排序。

       虽然不能直接用sortmap进行排序,那么我们可不可以迂回一下,把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<U,V> &p) : first(p.first), second(p.second) { }  

12. }  


pair也是一个模板类,这样就实现了良好的通用性。它仅有两个数据成员firstsecond,即key value,而且

<utility>头文件中,还为pair重载了< 运算符, 具体实现如下: 

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,如果__xkey小于 __ykey则返回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) ,看清出,这里是ykey不小于xkey,结合前提条件,__x.first < __y.first不成立,即xkey不小于ykey 

即:  !(__y.first < __x.first)  &&   !(__x.first < __y.first )  等价于   __x.first == __y.first ,也就是说,第二种情况是在key相等的情况下,比较两者的valuesecond)。

这里比较令人费解的地方就是,为什么不直接写 __x.first == __y.first呢? 这么写看似费解,但其实也不无道理:前面讲过,作为mapkey必须实现<操作符的重载,但是并不保证==符也被重载了,如果key没有提供==,那么 __x.first == __y.first 这样写就错了。由此可见,stl中的代码是相当严谨的,值得我们好好研读。

 现在我们知道了pair类重载了<符,但是它并不是按照value进行比较的,而是先对key进行比较,key相等时候才对value进行比较。显然不能满足我们按value进行排序的要求。

而且,既然pair已经重载了<符,而且我们不能修改其实现,又不能在外部重复实现重载<符。

1. typedef pair<string, int> PAIR;  

2. bool operator< (const PAIR& lhs, const PAIR& rhs) {  

3.     return lhs.second < rhs.second;  

4. }  


如果pair类本身没有重载<符,那么我们按照上面的代码重载<符,是可以实现对pair的按value比较的。现在这样做不行了,甚至会出错(编译器不同,严格的就报错)。

那么我们如何实现对pairvalue进行比较呢? 第一种:是最原始的方法,写一个比较函数; 第二种:刚才用到了,写一个函数对象。这两种方式实现起来都比较简单。

1. typedef pair<string, int> 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是在定义时指定的,所以传参的时候直接传入函数对象的类名,就像指定keyvalue时指定的类型名一样;sort算法是在调用时指定的,需要传入一个对象,当然这个也简单,类名()就会调用构造函数生成对象。

这里也可以传入一个函数指针,就是把上面说的第一种方法的函数名传过来。(应该是存在函数指针到函数对象的转换,或者两者调用形式上是一致的,具体确切原因还不明白,希望知道的朋友给讲下,先谢谢了。)

【参考代码】

1. int main() {  

2.   map<string, int> name_score_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<PAIR> name_score_vec(name_score_map.begin(), name_score_map.end());  

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中的第三个对象,因为STLlist是以双链的list来实现的, 它不支持随机存取。vectordeque(向量和双端队列)和一些其他的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 <list<int>> veclis;
这样写会报错,而这样写:
vector <list <int> > 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 <int, greater<int> > set1

greater 是另一个模板函数(范型函数),当值放置在容器中后,它用来为这些值排序。如果你想按降序排列这些值,你可以这样写:

set <int, less<int> > set1

11.vectorreserve只是预先划分一块内存给vector使用,主要是为了提高效率:避免在不断push_back的过程中,由于容量变动导致的重新分配!

如果没有的话,push_back的之后,当内存不够了,就会有内存的重新分配和元素的拷贝。这是绝对很低效的。

如果 vector的容量不够了,它会
1. 重新分配更多的空间(一般是增加 N/2N为原容量)
2. 将现有vector中的数据逐个拷贝到新空间
3. 释放旧空间中的所有元素
4. vector 指向新空间

 

 

发布了49 篇原创文章 · 获赞 29 · 访问量 3万+
展开阅读全文
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览