AI 助理
文档备案控制台
开发者社区 云原生 容器服务 文章 正文

【转】c++中Vector等STL容器的自定义排序

2017-11-23 1508
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

如果要自己定义STL容器的元素类最好满足STL容器对元素的要求
    必须要求：
     1、Copy构造函数
     2、赋值=操作符
     3、能够销毁对象的析构函数
    另外：
     1、可用的缺省构造函数，序列型容器必须，用于初始化元素
     2、==操作符定义，用于判断相等
     3、<操作符定义，关联型容器必须，用于缺省排序

 

你可在struct內加入 operator < ,就可以使struct有排序能力.
因為而你的pcd struct內沒有指針,所以不須要有copy constructor
和copy assignment, 編譯器會為你提供的, 你不須要自己做的.
當你要排序時只要寫 sort( obj.begin(), obj.end() )就可.

 

以上内容取自帖子：http://bbs.csdn.net/topics/40228627

另一篇参考地址：http://blog.csdn.net/tigernana/article/details/7293758

以下取自帖子：http://blog.csdn.net/guang11cheng/article/details/7556697

 

三种方式实现vector的自定义排序

方法1：重载运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <vector>
  #include <algorithm>
  #include <functional>
 
using  namespace  std;
struct  TItem
{
     int  m_i32Type;
     int  m_i32ID;
 
     bool  operator  <( const  TItem& rhs)  const  // 升序排序时必须写的函数
     {
         return  m_i32Type < rhs.m_i32Type;
     }
     bool  operator  >( const  TItem& rhs)  const  // 降序排序时必须写的函数
     {
         return  m_i32Type > rhs.m_i32Type;
     }
};
int  main()
{
     vector<TItem> stItemVec;
 
 
     TItem stItem1;
     stItem1.m_i32Type = 1;
     stItem1.m_i32ID = 1;
 
     TItem stItem2;
     stItem2.m_i32Type = 2;
     stItem2.m_i32ID = 2;
 
     TItem stItem3;
     stItem3.m_i32Type = 3;
     stItem3.m_i32ID = 3;
 
     TItem stItem4;
     stItem4.m_i32Type = 2;
     stItem4.m_i32ID = 4;
 
     stItemVec.push_back(stItem1);
     stItemVec.push_back(stItem2);
     stItemVec.push_back(stItem3);
     stItemVec.push_back(stItem4);
 
     // 升序排序
     sort(stItemVec.begin(), stItemVec.end(), less<TItem>());
     // 或者sort(ctn.begin(), ctn.end());   默认情况为升序
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
         printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
 
     printf( "--\n" );
 
     // 降序排序
     sort(stItemVec.begin(), stItemVec.end(), greater<TItem>());
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
         printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
 
     return  0;
}

方法2：全局的比较函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
bool  lessmark( const  TItem& stItem1,  const  TItem& stItem2)
  {
      return  stItem1.m_i32Type < stItem2.m_i32Type;
  }
  
 
bool  greatermark( const  TItem& stItem1,  const  TItem& stItem2)
  {
      return  stItem1.m_i32Type > stItem2.m_i32Type;
  }
  
 
int  main()
  {
      vector<TItem> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(stItem1);
      stItemVec.push_back(stItem2);
      stItemVec.push_back(stItem3);
      stItemVec.push_back(stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), lessmark);  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), greatermark);  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     return  0;
  }

方法3：函数对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
class  CompLess
  {
  public :
      bool  operator  ()( const  TItem& stItem1,  const  TItem& stItem2)
      {
          return  stItem1.m_i32Type < stItem2.m_i32Type;
      }
  };
  
 
class  CompGreater
  {
  public :
      bool  operator  ()( const  TItem& stItem1,  const  TItem& stItem2)
      {
          return  stItem1.m_i32Type > stItem2.m_i32Type;
      }
  };
  
 
int  main()
  {
      vector<TItem> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(stItem1);
      stItemVec.push_back(stItem2);
      stItemVec.push_back(stItem3);
      stItemVec.push_back(stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompLess());  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompGreater());  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     return  0;
  }
  
 
/*
  结果如下：
  type: 1, id: 1
  type: 2, id: 2
  type: 2, id: 4
  type: 3, id: 3
  --
  type: 3, id: 3
  type: 2, id: 2
  type: 2, id: 4
  type: 1, id: 1
  可以看出vector的sort的稳定的。
  */

问题：

1，示例代码中只有>和<关系处理，==关系是如何推导出来的？

2，排序时要移动元素，效率怎样？

3，如果自定义结构定义在一个类的内部，使用函数对象进行排序，这个函数对象可以作为类的成员函数吗？

4，在上面的例子中，vector中存放的都是结构（对象）本身，如果存放的是结构指针，该如何排序呢？此时只能通过全局的比较函数或者函数对象来做，且比较函数的参数要是指针类型的，如下：

（1）全局的比较函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
bool  CompLess( const  TItem* pstItem1,  const  TItem* pstItem2)
  {
      return  pstItem1->m_i32Type < pstItem2->m_i32Type;
  }
  
 
bool  CompGreater( const  TItem* pstItem1,  const  TItem* pstItem2)
  {
      return  pstItem1->m_i32Type > pstItem2->m_i32Type;
  }
  
 
int  main()
  {
      vector<TItem*> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(&stItem1);
      stItemVec.push_back(&stItem2);
      stItemVec.push_back(&stItem3);
      stItemVec.push_back(&stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompLess);  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompGreater);  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
     return  0;
  }

　　（2）函数对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
class  CompLess
  {
  public :
      bool  operator  ()( const  TItem* pstItem1,  const  TItem* pstItem2)
      {
          return  pstItem1->m_i32Type < pstItem2->m_i32Type;
      }
  };
  
 
class  CompGreater
  {
  public :
      bool  operator  ()( const  TItem* pstItem1,  const  TItem* pstItem2)
      {
          return  pstItem1->m_i32Type > pstItem2->m_i32Type;
      }
  };
  
 
int  main()
  {
      vector<TItem*> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(&stItem1);
      stItemVec.push_back(&stItem2);
      stItemVec.push_back(&stItem3);
      stItemVec.push_back(&stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompLess());  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompGreater());  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
 
     return  0;
  }

　　本文转自编程小翁博客园博客，原文链接：http://www.cnblogs.com/wengzilin/p/3937491.html，如需转载请自行联系原作者

文章标签：
C++
容器
关键词：
C++ stl
C++自定义
C++容器
容器stl
C++ vector
文艺小青年
目录
相关文章
蒋星熠Jaxonic
|
8月前
|
缓存 算法 程序员
C++STL底层原理：探秘标准模板库的内部机制
🌟蒋星熠Jaxonic带你深入STL底层：从容器内存管理到红黑树、哈希表，剖析迭代器、算法与分配器核心机制，揭秘C++标准库的高效设计哲学与性能优化实践。
蒋星熠Jaxonic
759 3
C++STL底层原理：探秘标准模板库的内部机制
ephemerals__
|
编译器 C++ 容器
【c++丨STL】基于红黑树模拟实现set和map（附源码）
本文基于红黑树的实现，模拟了STL中的`set`和`map`容器。通过封装同一棵红黑树并进行适配修改，实现了两种容器的功能。主要步骤包括：1) 修改红黑树节点结构以支持不同数据类型；2) 使用仿函数适配键值比较逻辑；3) 实现双向迭代器支持遍历操作；4) 封装`insert`、`find`等接口，并为`map`实现`operator[]`。最终，通过测试代码验证了功能的正确性。此实现减少了代码冗余，展示了模板与仿函数的强大灵活性。
ephemerals__
392 2
ephemerals__
|
存储 算法 C++
【c++丨STL】map/multimap的使用
本文详细介绍了STL关联式容器中的`map`和`multimap`的使用方法。`map`基于红黑树实现，内部元素按键自动升序排列，存储键值对，支持通过键访问或修改值；而`multimap`允许存在重复键。文章从构造函数、迭代器、容量接口、元素访问接口、增删操作到其他操作接口全面解析了`map`的功能，并通过实例演示了如何用`map`统计字符串数组中各元素的出现次数。最后对比了`map`与`set`的区别，强调了`map`在处理键值关系时的优势。
ephemerals__
800 73
蓝易云
|
存储 C++
UE5 C++：自定义Http节点获取Header数据
综上，通过为UE5创建一个自定义HTTP请求类并覆盖GetResult方法，就能成功地从HTTP响应的Header数据中提取信息。在项目中使用自定义类，不仅可以方便地访问响应头数据，也可随时使用这些信息。希望这种方法可以为你的开发过程带来便利和效益。
蓝易云
559 35
平凡程序猿~
|
存储 缓存 C++
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
C++ 标准模板库（STL）提供了一组功能强大的容器类，用于存储和操作数据集合。不同的容器具有独特的特性和应用场景，因此选择合适的容器对于程序的性能和代码的可读性至关重要。对于刚接触 C++ 的开发者来说，了解这些容器的基础知识以及它们的特点是迈向高效编程的重要一步。本文将详细介绍 C++ 常用的容器，包括序列容器（`std::vector`、`std::array`、`std::list`、`std::deque`）、关联容器（`std::set`、`std::map`）和无序容器（`std::unordered_set`、`std::unordered_map`），全面解析它们的特点、用法
平凡程序猿~
983 1
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
ephemerals__
|
存储 算法 C++
【c++丨STL】set/multiset的使用
本文深入解析了STL中的`set`和`multiset`容器，二者均为关联式容器，底层基于红黑树实现。`set`支持唯一性元素存储并自动排序，适用于高效查找场景；`multiset`允许重复元素。两者均具备O(logN)的插入、删除与查找复杂度。文章详细介绍了构造函数、迭代器、容量接口、增删操作（如`insert`、`erase`）、查找统计（如`find`、`count`）及`multiset`特有的区间操作（如`lower_bound`、`upper_bound`、`equal_range`）。最后预告了`map`容器的学习，其作为键值对存储的关联式容器，同样基于红黑树，具有高效操作特性。
ephemerals__
686 3
ephemerals__
|
存储 算法 C++
【c++丨STL】priority_queue（优先级队列）的使用与模拟实现
本文介绍了STL中的容器适配器`priority_queue`（优先级队列）。`priority_queue`根据严格的弱排序标准设计，确保其第一个元素始终是最大元素。它底层使用堆结构实现，支持大堆和小堆，默认为大堆。常用操作包括构造函数、`empty`、`size`、`top`、`push`、`pop`和`swap`等。我们还模拟实现了`priority_queue`，通过仿函数控制堆的类型，并调用封装容器的接口实现功能。最后，感谢大家的支持与关注。
ephemerals__
962 1
平凡程序猿~
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
436 0
ephemerals__
|
编译器 C++ 容器
【c++11】c++11新特性（上）（列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式）
C++11为C++带来了革命性变化，引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式，initializer_list简化了容器多元素初始化；右值引用和移动语义优化了资源管理，减少拷贝开销；类新增移动构造和移动赋值函数提升性能；lambda表达式提供匿名函数对象，增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展，提升了开发效率与程序性能。
ephemerals__
553 12
hahaha无
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果：注意：类模板中的成员函数若是放在类外定义时，需要加模板参数列表。return 0;
hahaha无
288 0
云原生

容器服务

热门文章

最新文章

  • 1
    Minikube - Kubernetes本地实验环境
  • 2
    Docker的Windows容器初体验
  • 3
    Docker学习路线图 (持续更新中)
  • 4
    利用Zipkin对Spring Cloud应用进行服务追踪分析
  • 5
    当 Kubernetes 遇到阿里云
  • 6
    基于Docker容器的，Jenkins、GitLab构建持续集成CI
  • 7
    谈谈 Docker Volume 之权限管理（一）
  • 8
    容器镜像服务 Docker镜像的基本使用
  • 9
    使用阿里云容器服务Jenkins 2.0实现持续集成之Pipeline篇(updated on 2016.12.23)
  • 10
    利用Helm简化Kubernetes应用部署
  • 1
    WordPressACK
    154
  • 2
    [yahoon 原创] ArgoCD从内网的GitLab Repo部署应用
    185
  • 3
    实惠的云服务器推荐！！
    153
  • 4
    使用ASMGlobalRateLimiter实现基于调用来源和请求路径的精细化全局限流
    185
  • 5
    【赵渝强老师】Docker容器的跨节点通信
    288
  • 6
    最全的docker命令参数解释及命令用法
    1886
  • 7
    最全的kubectl命令用法
    938
  • 8
    一文讲解kubernetes的gateway Api的功能、架构、部署、管理及使用
    1586
  • 9
    xkube v4.0发布，完全开发源代码并新增k8s网关、亲和性很多k8s实用功能
    634
  • 10
    Docker教程
    561

    • 相关课程

    更多
  • 容器持久化储存训练营
  • 现代应用容器技术快速入门
  • 云计算、容器和云原生基础课程
  • Serverless 容器从入门到精通: - Serverless Kubernetes
  • 容器安全与Palo Alto Networks解决方案
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！