STL之partial_sort

最新推荐文章于 2024-01-28 23:06:23 发布
转载 最新推荐文章于 2024-01-28 23:06:23 发布 · 326 阅读 · 0

本文深入解析了部分排序算法partial_sort及其辅助函数的功能与实现机制，包括两种版本：默认使用小于运算符进行比较的版本和使用自定义比较函数的版本。此外，还介绍了partial_sort_copy函数，它将排序后的元素复制到另一个容器中。 
// partial_sort, partial_sort_copy, and auxiliary functions.
//重新安排序列[first,last)，使序列前半部分middle-first个最小元素以递增顺序排序，并将其置于[first,middle)
//其余last-middle个元素不指定任何排序，并将其置于[middle,last)
//注意：迭代器middle是在[first,last)范围之内

/*
函数功能：Rearranges the elements in the range [first,last), 
in such a way that the elements before middle are the smallest elements in the entire range 
and are sorted in ascending order, while the remaining elements are left without any specific order.

函数原型：
default (1)	版本一 operator< 
	template <class RandomAccessIterator>
	void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,
                     RandomAccessIterator last);
custom (2) 版本二 comp	
	template <class RandomAccessIterator, class Compare>
	void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,
                     RandomAccessIterator last, Compare comp);
*/

template <class _RandomAccessIter, class _Tp>
void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
                    _RandomAccessIter __last, _Tp*) {
		//利用heap的知识，在SGI STL中，是采用最大堆
		//将[first,middle)区间的元素创建成最大堆
		//再根据最大堆的性质，一个一个弹出堆，并将其保存，即堆排序
  make_heap(__first, __middle);//创建最大堆，定义与<stl_heap.h>文件
  //以下是在区间中[first,last)找出middle-first个最小元素
  //这里的是将后半部分[middle,last)的元素依次与最大堆的根节点元素(即堆的最大元素)比较
  //若小于堆的最大元素，则与堆的最大元素交换，并调整堆，使其依次成为最大堆
  //若不小于堆的最大元素，则不作任何操作
  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
    if (*__i < *__first) 
      __pop_heap(__first, __middle, __i, _Tp(*__i),
                 __DISTANCE_TYPE(__first));
  sort_heap(__first, __middle);//对最大堆进行堆排序
}
//版本一
template <class _RandomAccessIter>
inline void partial_sort(_RandomAccessIter __first,
                         _RandomAccessIter __middle,
                         _RandomAccessIter __last) {
  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type,
                 _LessThanComparable);
  __partial_sort(__first, __middle, __last, __VALUE_TYPE(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
                    _RandomAccessIter __last, _Tp*, _Compare __comp) {
  make_heap(__first, __middle, __comp);
  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
    if (__comp(*__i, *__first))
      __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
                 __DISTANCE_TYPE(__first));
  sort_heap(__first, __middle, __comp);
}
//版本二
template <class _RandomAccessIter, class _Compare>
inline void partial_sort(_RandomAccessIter __first,
                         _RandomAccessIter __middle,
                         _RandomAccessIter __last, _Compare __comp) {
  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
  __STL_BINARY_FUNCTION_CHECK(_Compare, bool, 
      typename iterator_traits<_RandomAccessIter>::value_type,
      typename iterator_traits<_RandomAccessIter>::value_type);
  __partial_sort(__first, __middle, __last, __VALUE_TYPE(__first), __comp);
}
//partial_sort_copy与partial_sort的实现机制是相同，只是partial_sort_copy将元素排序后放在以result起始的容器中
template <class _InputIter, class _RandomAccessIter, class _Distance,
          class _Tp>
_RandomAccessIter __partial_sort_copy(_InputIter __first,
                                      _InputIter __last,
                                      _RandomAccessIter __result_first,
                                      _RandomAccessIter __result_last, 
                                      _Distance*, _Tp*) {
  if (__result_first == __result_last) return __result_last;
  _RandomAccessIter __result_real_last = __result_first;
  while(__first != __last && __result_real_last != __result_last) {
    *__result_real_last = *__first;
    ++__result_real_last;
    ++__first;
  }
  make_heap(__result_first, __result_real_last);
  while (__first != __last) {
    if (*__first < *__result_first) 
      __adjust_heap(__result_first, _Distance(0),
                    _Distance(__result_real_last - __result_first),
                    _Tp(*__first));
    ++__first;
  }
  sort_heap(__result_first, __result_real_last);
  return __result_real_last;
}

template <class _InputIter, class _RandomAccessIter>
inline _RandomAccessIter
partial_sort_copy(_InputIter __first, _InputIter __last,
                  _RandomAccessIter __result_first,
                  _RandomAccessIter __result_last) {
  __STL_REQUIRES(_InputIter, _InputIterator);
  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
  __STL_CONVERTIBLE(typename iterator_traits<_InputIter>::value_type,
                    typename iterator_traits<_RandomAccessIter>::value_type);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type,
                 _LessThanComparable);
  __STL_REQUIRES(typename iterator_traits<_InputIter>::value_type,
                 _LessThanComparable);
  return __partial_sort_copy(__first, __last, __result_first, __result_last, 
                             __DISTANCE_TYPE(__result_first),
                             __VALUE_TYPE(__first));
}

template <class _InputIter, class _RandomAccessIter, class _Compare,
          class _Distance, class _Tp>
_RandomAccessIter __partial_sort_copy(_InputIter __first,
                                         _InputIter __last,
                                         _RandomAccessIter __result_first,
                                         _RandomAccessIter __result_last,
                                         _Compare __comp, _Distance*, _Tp*) {
  if (__result_first == __result_last) return __result_last;
  _RandomAccessIter __result_real_last = __result_first;
  while(__first != __last && __result_real_last != __result_last) {
    *__result_real_last = *__first;
    ++__result_real_last;
    ++__first;
  }
  make_heap(__result_first, __result_real_last, __comp);
  while (__first != __last) {
    if (__comp(*__first, *__result_first))
      __adjust_heap(__result_first, _Distance(0),
                    _Distance(__result_real_last - __result_first),
                    _Tp(*__first),
                    __comp);
    ++__first;
  }
  sort_heap(__result_first, __result_real_last, __comp);
  return __result_real_last;
}

template <class _InputIter, class _RandomAccessIter, class _Compare>
inline _RandomAccessIter
partial_sort_copy(_InputIter __first, _InputIter __last,
                  _RandomAccessIter __result_first,
                  _RandomAccessIter __result_last, _Compare __comp) {
  __STL_REQUIRES(_InputIter, _InputIterator);
  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
  __STL_CONVERTIBLE(typename iterator_traits<_InputIter>::value_type,
                    typename iterator_traits<_RandomAccessIter>::value_type);
  __STL_BINARY_FUNCTION_CHECK(_Compare, bool,
     typename iterator_traits<_RandomAccessIter>::value_type,
     typename iterator_traits<_RandomAccessIter>::value_type);  
  return __partial_sort_copy(__first, __last, __result_first, __result_last,
                             __comp,
                             __DISTANCE_TYPE(__result_first),
                             __VALUE_TYPE(__first));
}

STL partial_sort排序算法
JIWilliams
12-10 517
通过示例很容易理解什么是部分排序。假设有一个容器，它保存了 100 万个数值，但我们只对其中最小的 100 个感兴趣。可以对容器的全部内容排序，然后选择前 100 个元素，但这可能有点消耗时间。这时候需要使用部分排序，只需要这些数中的前100个是有序放置的。 对于部分排序，有一个特殊的算法 partial_sort()，它需要 3 个随机访问迭代器作为参数。如果这个函数的参数是 first、se...
无聊写排序之 ----部分排序(Partial Sort)
尜尜君的小世界
07-28 6920
当有一个无序的序列集合的时候，我们想知道这个序列里面按照某种排序关系最大的m个或者前top个有序的元素。比如我又100个学生，我只想知道排名前20的学生的名次列表，剩余的我并不关心，如何去得到呢？ 当然你脑海中第一个闪过的便是sort，做一次排序，取排序后前面的20不就好了吗？ 没错，排序作为做常规的方法，肯定是最先想到的，这里要介绍的是比排序来的更快更直接的一个算法：部分排序（partial_s
c++ stl 排序算法 局部排序partial_sort、partial_sort_copy
qq_44800780的博客
01-04 393
使用例子: int main() { deque<int>a; INSERT_ELEMENTS(a, 3, 7); INSERT_ELEMENTS(a, 2, 6); INSERT_ELEMENTS(a, 1, 5); PRINT_ELEMENTS(a); partial_sort(a.begin(), a.begin() + 5, a.end()); ...
STL之partial_sort排序学习
08-28 3844
partial_sort(beg,mid,end) partial_sort(beg,mid,end,comp) 对mid-beg个元素进行排序，也就是说，如果migd-beg等于42，则该函数将有序次序中的最小值元素放在序列中 的前42个位置。partial_sort完成
STL之partial_sort排序
qq_26139541的博客
07-25 387
partial_sort(beg,mid,end) partial_sort(beg,mid,end,comp) 对mid-beg个元素进行排序，也就是说，如果migd-beg等于42，则该函数将有序次序中的最小值元素放在序列中 的前42个位置。partial_sort完成之后，从beg到mid(但不包括mid)范围内的元素时有序的，已排序范围内没有 元素大于mid之后的元素。未排序元素之间的次序是未指定的。 例如： 有一个赛跑成绩的集合，我们想知道前三名的成绩但并不关心其他名次的次序，可以这样对这个序列进
C++ partial_sort()排序函数用法详解(深入了解,一文学会)
断点
07-30 6846
partial_sort()分为partial_sort()和partial_sort_copy()两种函数。 partial_sort()排序函数主要用在非常大的容器筛选最大或者最小值来使用，例如：容器A有100万个元素，需要找出最大或者最小的10个元素，这时候就需要用到partial_sort()和partial_sort_copy()两种函数。 partial_sort() 重新调整容器元素顺序，达到选出最大值或者最小值的目的；partial_sor......
【C++】sort()、stable_sort()和partial_sort()排序函数详解
不定时分享，互相学习，共同进步
11-03 7811
本文通过示例对排序函数进行了详细的解读，在选择排序函数时，需要考虑你的具体需求。如果你不需要保持相等元素的顺序，那么可以使用 std::sort()。如果你需要保持相等元素的顺序，那么可以使用 std::stable_sort()。如果你只想对序列的一部分进行排序，那么可以使用 std::partial_sort()。
c++ STL partial_sort() 部分排序
Aajbelieve的博客
05-26 1433
STL partial_sort() 部分排序 使用背景： 对于一个长度较大的数组，如果我们要想知道该数组的前m个小的元素是什么，我们可以对整个数数进行排序，然后取前m个，例如在长度为10w的数组中，找出前50个小的数，这样就比较费时，显得杀鸡用牛刀 这时我们可以使用STL 中的 partial_sort()函数 解决这个问题 使用方法： 头文件，algorithm 使用方法： 在数组(容器)的 指定区间 begin位置 ~end位置（操作区间），找出前m个小的数 ：** partial_sort ( be
STL_算法_局部排序(partial_sort、partial_sort_copy)
寻找&星空の孩子
01-29 2445
C++ Primer 学习中。。。   简单记录下我的学习过程 (代码为主) /***************************************** // partial_sort(b,se,e) partial_sort(b,se,e,p) partial_sort_copy(sb,se,db,de) partial_sort_copy(sb
STL algorithm算法partial_sort,partial_sort_copy(42)
roaylchen的博客
09-22 2689
partial_sort原型： std::partial_sort default (1) template void partial_sort (RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last)
【STL】算法 — partial_sort
Nestle的专栏
05-15 8316
partial_sort接受一个middle迭代器，使序列中的middle-first个最小元素以递增顺序排序，置于[first, middle)内。下面是测试代码： #include #include #include using namespace std; int main() { int a[] = {10,9,8,7,6,5,4,3,2,1,0}; vec
STL源码解释-----sort()&&partial_sort()
modiziri的专栏
03-22 1956
原来虽然Quick和Heap的时间复杂性是一样的，但堆排序的常熟因子还是大些的，并且堆排序过程中重组堆其实也不是个省时的事。
partial_sort
jfkidear的专栏
06-05 893
partial_sort 编辑 目录 1函数简介 2函数实现原理 3函数应用举例 1函数简介编辑 partial_sort[1]是C++STL中的函数 函数原型有： partial_sort(beg,mid,end) partial_sort(beg,mid,end,comp)
partial_sort()
weixin_33725807的博客
04-11 151
2019独角兽企业重金招聘Python工程师标准>>> ...
02_有点基础来看STL排序算法之partial_sort
成长需要沉淀。
01-28 466
partial_sort函数将[first, last]范围内的元素进行部分排序，使得从[first, middle)的元素按照递增顺序排列，其余元素不保证有序。也就是说，middle之前的元素是排过序的，middle之后的元素未排序。在实现排序功能前，partial_sort函数首先将元素按照一定规则生成部分堆，然后重复执行pop_heap操作，将堆顶元素放到middle前，重新调整剩余元素的顺序，使之形成新的堆结构。Partial_sort 算法函数，用于对指定区间的元素进行部分排序。
partial_sort 的使用
思不凉
06-09 6301
partial_sort 的使用 partial_sort 是C++ STL 算法组件中的其中一个算法，其作用是对序列局部元素进行排序，默认排序是升序。它有两个重载函数。要使用partial_sort 需要引用头文件 algorithm。 下面是一个例子： 引用头文件，main 方法，容器的定义、赋值与输出，partial_sort 的调用。 代码： #include <iostream&g...
partial_sort的用法
zhuxin
11-21 445
#include #include using namespace std; bool cmp(int &a,int &b) { return a>b; } int main (void) { int iArray[] = {1, 15, -235, 0, 15, 2348, -2345, 999}; for (size_t i = 0;i < si
C++ partial_sort（部分排序）
qq_43328751的博客
10-05 1293
参考：http://c.biancheng.net/view/564.html 定义 假设有一个容器，它保存了 100 万个数值，但我们只对其中最小的 100 个感兴趣。可以对容器的全部内容排序，然后选择前 100 个元素，但这可能有点消耗时间。这时候需要使用部分排序，只需要这些数中的前100个是有序放置的。 对于部分排序，有一个特殊的算法 partial_sort()，它需要 3 个随机访问迭代器作为参数。如果这个函数的参数是 first、second 和 last，那么这个算法会被应用到 [firs.
std::partial_sort()
最新发布
04-09
### C++ `std::partial_sort` 函数详解 #### 定义与功能 `std::partial_sort` 是 C++ STL 中的一个算法，用于部分排序容器中的元素。它会将指定范围内的前 N 个小的元素按升序排列到目标位置上，而其余未涉及的部分则保持原样或无特定顺序[^1]。 该函数的主要特点是效率较高，因为它不需要对整个序列进行全面排序即可完成任务。其时间复杂度通常优于完全排序的操作（如 `std::sort`），尤其是在只需要获取少量有序数据的情况下非常有用。 --- #### 基本语法 以下是 `std::partial_sort` 的通用声明形式： ```cpp template< class RandomIt > void partial_sort( RandomIt first, RandomIt middle, RandomIt last ); template< class RandomIt, class Compare > void partial_sort( RandomIt first, RandomIt middle, RandomIt last, Compare comp ); ``` - **参数解释** - `first`: 输入区间的起始迭代器。 - `middle`: 部分排序结束的位置（即要保留多少个最小/最大值）。 - `last`: 输入区间的终止迭代器。 - `comp`(可选): 自定义比较函数对象，默认为 `<` 运算符。 对于 C++20 及更高版本，还支持带执行策略 (`ExecutionPolicy`) 的重载版本[^4]。 --- #### 使用示例 ##### 示例 1：字符串部分排序 下面是一个简单的例子，展示如何通过 `std::partial_sort` 对字符串的一部分进行排序。 ```cpp #include <iostream> #include <algorithm> #include <string> int main() { std::string s = "987654321"; // 将前五个字符从小到大排序 std::partial_sort(s.begin(), s.begin() + 5, s.end()); std::cout << s << std::endl; // 输出: 123459876 } ``` 此代码片段展示了如何利用 `std::partial_sort` 来仅改变原始字符串的一小部分内容，并不影响其他区域[^2]。 --- ##### 示例 2：自定义结构体排序 当处理更复杂的类型时，可以提供一个 lambda 表达式作为比较器来实现定制化行为。 ```cpp #include <iostream> #include <algorithm> #include <vector> struct SData { int m_nData; double m_dData; SData(int nData, double dData) : m_nData(nData), m_dData(dData) {} }; int main() { std::vector<SData> v; for (int i = 9; i > 0; --i) { v.emplace_back(i, static_cast<double>(i)); } // 按照成员变量 m_nData 升序排列前五项 std::partial_sort(v.begin(), v.begin() + 5, v.end(), [](const SData& a, const SData& b) -> bool { return a.m_nData < b.m_nData; }); for (const auto& item : v) { std::cout << item.m_nData << ' '; } std::cout << '\n'; // 输出: 1 2 3 4 5 9 8 7 6 } ``` 上述程序演示了针对用户定义的数据类型的灵活应用方式。 --- #### 注意事项 虽然 `std::partial_sort` 提供了一种高效的方法来进行局部排序，但在某些场景下可能并非最佳选择。如果仅仅是为了提取最前面若干个极值，则考虑采用堆队列技术——比如借助于 `std::nth_element` 或者优先级队列可能会更加合适[^4]。 另外需要注意的是，在调用过程中传入的有效区间 `[first,middle)` 和 `[middle,last)` 应满足基本条件约束；否则可能导致未定义的行为发生。 --- ### 总结 综上所述，`std::partial_sort` 不失为一种强大工具，尤其适用于那些只需关注整体集合中某一部分的情况之下。然而实际开发当中还需权衡性能需求以及具体应用场景等因素再做决定。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值