C++ 标准库 已排序区间算法

最新推荐文章于 2025-01-11 08:35:13 发布
最新推荐文章于 2025-01-11 08:35:13 发布
阅读量389 收藏
点赞数
分类专栏： # C++98/03 # STL 文章标签： merge lower_bound upper_bound set_union includes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/luoshabugui/article/details/107997893
版权
本文深入探讨了C++标准库中针对已排序区间的算法，包括std::binary_search、std::includes、std::lower_bound等，并通过具体示例展示了它们的功能与使用方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一 概述
  • C++ 标准库中提供了很多算法，定义于头文件 < algorithm >。本文主要探究以下用于 已排序区间 的算法：
    • std::binary_search 查找元素是否存在于某范围中
    • std::includes 范围是否包含另一范围
    • std::lower_bound 返回指向第一个不小于给定值的元素的迭代器
    • std::upper_bound 返回指向第一个大于给定值的元素的迭代器
    • std::equal_range 返回匹配特定键值的元素范围
    • std::merge 归并两个已排序区间到一个已排序区间
    • std::set_union 计算并集
    • std::set_intersection 计算交集
    • std::set_difference 计算差集
    • std::set_symmetric_difference 计算对称差
    • std::inplace_merge 归并两个相继已排序区间到一个排序区间（稳定排序）
    • std::partition_point 定位已划分范围的划分点
二 辅助函数
三 std::binary_search
  • 定义
template< class ForwardIt, class T >
bool binary_search( ForwardIt first, ForwardIt last, const T& value );(1)(until C++20)
template< class ForwardIt, class T >
constexpr bool binary_search( ForwardIt first, ForwardIt last, const T& value );(1)(since C++20)
template< class ForwardIt, class T, class Compare >
bool binary_search( ForwardIt first, ForwardIt last, const T& value, Compare comp );(2)(until C++20)
template< class ForwardIt, class T, class Compare >
constexpr bool binary_search( ForwardIt first, ForwardIt last, const T& value, 
                              Compare comp );(2)(since C++20)
  • Demo
if (1) {
  // std::binary_search 查找元素是否存在于某范围中
  std::vector<int> vc;
  fill(vc, 1, 6);
  print("vc: ", vc);
  std::cout << "find 6 in vc: " << std::boolalpha << std::binary_search(vc.begin(), vc.end(), 6) << std::endl;
  std::cout << "find 7 in vc: " << std::boolalpha << std::binary_search(vc.begin(), vc.end(), 7) << std::endl;
}
  • 结果
vc: 1 2 3 4 5 6
find 6 in vc: true
find 7 in vc: false
四 std::includes
  • 定义
template< class InputIt1, class InputIt2 >
bool includes( InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2 );(1)(until C++20)
template< class InputIt1, class InputIt2 >
constexpr bool includes( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2 );(1)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
bool includes( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
               ForwardIt2 first2, ForwardIt2 last2 );(2)(since C++17)	
template< class InputIt1, class InputIt2, class Compare >
bool includes( InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2, Compare comp );(3)(until C++20)
template< class InputIt1, class InputIt2, class Compare >
constexpr bool includes( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2, Compare comp );(3)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class Compare >
bool includes( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
               ForwardIt2 first2, ForwardIt2 last2, Compare comp );(4)(since C++17)

if (1) {
  // std::includes 范围是否包含另一范围
  std::vector<int> vc;
  fill(vc, 1, 6);
  std::vector<int> vc1;
  fill(vc1, 2, 4);
  std::vector<int> vc2;
  fill(vc2, 3, 7);
  print("vc: ", vc);
  print("vc1: ", vc1);
  print("vc2: ", vc2);
  std::cout << "vc1 in vc: " << std::boolalpha
  << std::includes(vc.begin(), vc.end(), vc1.begin(), vc1.end()) << std::endl;
  std::cout << "vc2 in vc: " << std::boolalpha
  << std::includes(vc.begin(), vc.end(), vc2.begin(), vc2.end()) << std::endl;
}
  • 结果
vc: 1 2 3 4 5 6
vc1: 2 3 4
vc2: 3 4 5 6 7
vc1 in vc: true
vc2 in vc: false
五 std::lower_bound
  • 定义
template< class ForwardIt, class T >
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value );(1)
(until C++20)
template< class ForwardIt, class T >
constexpr ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value );(1)
(since C++20)
template< class ForwardIt, class T, class Compare >
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value, Compare comp );(2)
(until C++20)
template< class ForwardIt, class T, class Compare >
constexpr ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value, 
                                 Compare comp );(2)(since C++20)
  • Demo
if (1) {
  // std::lower_bound 返回指向第一个不小于给定值的元素的迭代器
  std::vector<int> vc{1,3,5,7};
  print("vc: ", vc);
  std::cout << "lower_bound 5 in vc: "
            << *std::lower_bound(vc.begin(), vc.end(), 5) << std::endl;
}
  • 结果
vc: 1 3 5 7
lower_bound 5 in vc: 5
六 std::upper_bound
  • 定义
template< class ForwardIt, class T >
ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value );(1)(until C++20)
template< class ForwardIt, class T >
constexpr ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value );(1)(since C++20)	
template< class ForwardIt, class T, class Compare >
ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value, 
                       Compare comp );(2)(until C++20)
template< class ForwardIt, class T, class Compare >
constexpr ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value, 
                                 Compare comp );(2)(since C++20)
  • Demo
if (1) {
  // std::upper_bound 返回指向第一个大于给定值的元素的迭代器
  std::vector<int> vc{1, 3, 5, 7};
  print("vc: ", vc);
  std::cout << "upper_bound 5 in vc: "
            << *std::upper_bound(vc.begin(), vc.end(), 5) << std::endl;
}
  • 结果
vc: 1 3 5 7
upper_bound 5 in vc: 7
七 std::equal_range
  • 定义
template< class ForwardIt, class T >
std::pair<ForwardIt,ForwardIt>
    equal_range( ForwardIt first, ForwardIt last,
                 const T& value );(1)(until C++20)
template< class ForwardIt, class T >
constexpr std::pair<ForwardIt,ForwardIt>
    equal_range( ForwardIt first, ForwardIt last,
                           const T& value );(1)(since C++20)
template< class ForwardIt, class T, class Compare >
std::pair<ForwardIt,ForwardIt>
    equal_range( ForwardIt first, ForwardIt last,
                 const T& value, Compare comp );(2)(until C++20)
template< class ForwardIt, class T, class Compare >
constexpr std::pair<ForwardIt,ForwardIt>
    equal_range( ForwardIt first, ForwardIt last,
                 const T& value, Compare comp );(2)(since C++20)
  • Demo
if (1) {
  // std::equal_range 返回匹配特定键值的元素范围
  std::vector<int> vc{1, 3, 5, 7};
  print("vc: ", vc);
  auto p = std::equal_range(vc.begin(), vc.end(), 5);
  std::cout << "equal_range 5 in vc first pos: "
            << std::distance(vc.begin(), p.first) << std::endl;
  std::cout << "equal_range 5 in vc end pos: "
            << std::distance(vc.begin(), p.second) << std::endl;
}
  • 结果
equal_range 5 in vc first pos: 2
equal_range 5 in vc end pos: 3
八 std::merge
  • 定义
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt merge( InputIt1 first1, InputIt1 last1,
                InputIt2 first2, InputIt2 last2,
                OutputIt d_first );(1)(until C++20)
template< class InputIt1, class InputIt2, class OutputIt >
constexpr OutputIt merge( InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first );(1)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3 >
ForwardIt3 merge( ExecutionPolicy&& policy,
                  ForwardIt1 first1, ForwardIt1 last1,
                  ForwardIt2 first2, ForwardIt2 last2,
                  ForwardIt3 d_first );(2)(since C++17)	
template< class InputIt1, class InputIt2, class OutputIt, class Compare>
OutputIt merge( InputIt1 first1, InputIt1 last1,
                InputIt2 first2, InputIt2 last2,
                OutputIt d_first, Compare comp );(3)(until C++20)
template< class InputIt1, class InputIt2, class OutputIt, class Compare>
constexpr OutputIt merge( InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first, Compare comp );(3)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3, class Compare>
ForwardIt3 merge( ExecutionPolicy&& policy,
                  ForwardIt1 first1, ForwardIt1 last1,
                  ForwardIt2 first2, ForwardIt2 last2,
                  ForwardIt3 d_first, Compare comp );(4)(since C++17)
  • Demo
if (1) {
  // std::merge 归并两个已排序区间到一个已排序区间
  std::vector<int> vc1{1, 3, 5, 7};
  print("vc1: ", vc1);
  std::vector<int> vc2{2, 4, 6, 8};
  print("vc2: ", vc2);
  std::vector<int> vc3;
  print("vc3: ", vc3);
  auto p = std::merge(vc1.begin(), vc1.end(), vc2.begin(), vc2.end(), std::back_inserter(vc3));
  std::cout << "merge vc1 and vc2 to vc3: "<< std::endl;
  print("vc3: ", vc3);
}
  • 结果
vc1: 1 3 5 7
vc2: 2 4 6 8
vc3:
merge vc1 and vc2 to vc3:
vc3: 1 2 3 4 5 6 7 8
九 std::set_union
  • 定义
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_union( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, InputIt2 last2,
                    OutputIt d_first );(1)(until C++20)
template< class InputIt1, class InputIt2, class OutputIt >
constexpr OutputIt set_union( InputIt1 first1, InputIt1 last1,
                              InputIt2 first2, InputIt2 last2,
                              OutputIt d_first );(1)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3 >
ForwardIt3 set_union( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 first2, ForwardIt2 last2,
                    ForwardIt3 d_first );(2)(since C++17)
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
OutputIt set_union( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, InputIt2 last2,
                    OutputIt d_first, Compare comp );(3)(until C++20)
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
constexpr OutputIt set_union( InputIt1 first1, InputIt1 last1,
                              InputIt2 first2, InputIt2 last2,
                              OutputIt d_first, Compare comp );(3)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class ForwardIt3, class Compare >
ForwardIt3 set_union( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 first2, ForwardIt2 last2,
                    ForwardIt3 d_first, Compare comp );(4)(since C++17)
  • Demo
if (1) {
  // std::set_union 计算并集
  std::vector<int> vc1{1, 3, 5, 7};
  print("vc1: ", vc1);
  std::vector<int> vc2{2, 4, 6, 8};
  print("vc2: ", vc2);
  std::vector<int> vc3;
  print("vc3: ", vc3);
  auto p = std::set_union(vc1.begin(), vc1.end(), vc2.begin(), vc2.end(),
                      std::back_inserter(vc3));
  std::cout << "set_union vc1 and vc2 to vc3: " << std::endl;
  print("vc3: ", vc3);
}
  • 结果
vc1: 1 3 5 7
vc2: 2 4 6 8
vc3:
set_union vc1 and vc2 to vc3:
vc3: 1 2 3 4 5 6 7 8
十 std::set_intersection
  • 定义
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                           InputIt2 first2, InputIt2 last2,
                           OutputIt d_first );(1)(until C++20)
template< class InputIt1, class InputIt2, class OutputIt >
constexpr OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                                     InputIt2 first2, InputIt2 last2,
                                     OutputIt d_first );(1)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3 >
ForwardIt3 set_intersection( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                             ForwardIt2 first2, ForwardIt2 last2,
                             ForwardIt3 d_first );(2)(since C++17)
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                           InputIt2 first2, InputIt2 last2,
                           OutputIt d_first, Compare comp );(3)(until C++20)
template< class InputIt1, class InputIt2,
                    class OutputIt, class Compare >
constexpr OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                                     InputIt2 first2, InputIt2 last2,
                                     OutputIt d_first, Compare comp );(3)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class ForwardIt3, class Compare >
ForwardIt3 set_intersection( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                             ForwardIt2 first2, ForwardIt2 last2,
                             ForwardIt3 d_first, Compare comp );(4)(since C++17)
  • Demo
if (1) {
  // std::set_intersection 计算交集
  std::vector<int> vc1{1, 2, 3, 5, 7};
  print("vc1: ", vc1);
  std::vector<int> vc2{2, 4, 6, 8};
  print("vc2: ", vc2);
  std::vector<int> vc3;
  print("vc3: ", vc3);
  auto p = std::set_intersection(vc1.begin(), vc1.end(), vc2.begin(), vc2.end(),
                      std::back_inserter(vc3));
  std::cout << "set_intersection vc1 and vc2 to vc3: " << std::endl;
  print("vc3: ", vc3);
}
  • 结果
vc1: 1 2 3 5 7
vc2: 2 4 6 8
vc3:
set_intersection vc1 and vc2 to vc3:
vc3: 2
十一 std::set_difference
  • 定义
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,
                         OutputIt d_first );(1)(until C++20)
template< class InputIt1, class InputIt2, class OutputIt >
constexpr OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt d_first );(1)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3 >
ForwardIt3 set_difference( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                           ForwardIt2 first2, ForwardIt2 last2,
                           ForwardIt3 d_first );(2)(since C++17)	
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,
                         OutputIt d_first, Compare comp );(3)(until C++20)
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
constexpr OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt d_first, Compare comp );(3)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class ForwardIt3, class Compare >
ForwardIt3 set_difference( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                           ForwardIt2 first2, ForwardIt2 last2,
                           ForwardIt3 d_first, Compare comp );(4)(since C++17)
  • Demo
if (1) {
  // std::set_difference 计算差集
  std::vector<int> vc1{1, 2, 3, 5, 7};
  print("vc1: ", vc1);
  std::vector<int> vc2{2, 4, 6, 8};
  print("vc2: ", vc2);
  std::vector<int> vc3;
  print("vc3: ", vc3);
  auto p = std::set_difference(vc1.begin(), vc1.end(), vc2.begin(), vc2.end(),
                      std::back_inserter(vc3));
  std::cout << "set_difference vc1 and vc2 to vc3: " << std::endl;
  print("vc3: ", vc3);
}
  • 结果
vc1: 1 2 3 5 7
vc2: 2 4 6 8
vc3:
set_difference vc1 and vc2 to vc3:
vc3: 1 3 5 7
十二 std::set_symmetric_difference
  • 定义
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt d_first );(1)(until C++20)
template< class InputIt1, class InputIt2, class OutputIt >
constexpr OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                                             InputIt2 first2, InputIt2 last2,
                                             OutputIt d_first );(1)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3 >
ForwardIt3 set_symmetric_difference( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                                   ForwardIt2 first2, ForwardIt2 last2,
                                   ForwardIt3 d_first );(2)	(since C++17)
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt d_first, Compare comp );(3)(until C++20)
template< class InputIt1, class InputIt2,
          class OutputIt, class Compare >
constexpr OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                                             InputIt2 first2, InputIt2 last2,
                                             OutputIt d_first, Compare comp );(3)(since C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class ForwardIt3, class Compare >
ForwardIt3 set_symmetric_difference( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                                   ForwardIt2 first2, ForwardIt2 last2,
                                   ForwardIt3 d_first, Compare comp );(4)(since C++17)
  • Demo
if (1) {
  // std::set_symmetric_difference 计算对称差
  std::vector<int> vc1{1, 2, 3, 5, 7};
  print("vc1: ", vc1);
  std::vector<int> vc2{2, 4, 6, 8};
  print("vc2: ", vc2);
  std::vector<int> vc3;
  print("vc3: ", vc3);
  auto p = std::set_symmetric_difference(vc1.begin(), vc1.end(), vc2.begin(), vc2.end(),
                      std::back_inserter(vc3));
  std::cout << "set_symmetric_difference vc1 and vc2 to vc3: " << std::endl;
  print("vc3: ", vc3);
}
  • 结果
vc1: 1 2 3 5 7
vc2: 2 4 6 8
vc3:
set_symmetric_difference vc1 and vc2 to vc3:
vc3: 1 3 4 5 6 7 8
  • 说明
    • 数学上，两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。
十三 std::inplace_merge
  • 定义
template< class BidirIt >
void inplace_merge( BidirIt first, BidirIt middle, BidirIt last );(1)	
template< class ExecutionPolicy, class BidirIt >
void inplace_merge( ExecutionPolicy&& policy, BidirIt first, 
                    BidirIt middle, BidirIt last );(2)(since C++17)
template< class BidirIt, class Compare>
void inplace_merge( BidirIt first, BidirIt middle, BidirIt last, Compare comp );(3)	
template< class ExecutionPolicy, class BidirIt, class Compare>
void inplace_merge( ExecutionPolicy&& policy, BidirIt first, BidirIt middle, 
                    BidirIt last, Compare comp );(4)(since C++17)
  • Demo
if (1) {
  // std::inplace_merge 归并两个相继已排序区间到一个排序区间（稳定排序）
  std::vector<std::pair<int, string>> vc{
      {1, "tom"}, {3, "lee"}, {1, "john"}, {5, "kate"}};
  for(auto item : vc) {
    std::cout << "{" << item.first << ", " << item.second << "}" << std::endl;
  }
  std::inplace_merge(vc.begin(), vc.begin() + 2, vc.end());
  std::cout << "after inplace_merge: " << std::endl;
  for (auto item : vc) {
    std::cout << "{" << item.first << ", " << item.second << "}" << std::endl;
  }
}
  • 结果
{1, tom}
{3, lee}
{1, john}
{5, kate}
after inplace_merge:
{1, john}
{1, tom}
{3, lee}
{5, kate}
十四 std::partition_point
  • 定义
template< class ForwardIt, class UnaryPredicate >
ForwardIt partition_point( ForwardIt first, ForwardIt last, 
                           UnaryPredicate p );(since C++11)(until C++20)
template< class ForwardIt, class UnaryPredicate >
constexpr ForwardIt partition_point( ForwardIt first, ForwardIt last, 
                                     UnaryPredicate p );(since C++20)
  • Demo
if (1) {
  // std::partition_point 定位已划分范围的划分点
  std::vector<int> vc;
  fill(vc, 1, 6);
  print("vc: ", vc);
  std::partition(vc.begin(), vc.end(), even);
  print("vc: ", vc);
  auto it = std::partition_point(vc.begin(), vc.end(), even);
  std::cout << "partition_point vc of noteven: " << std::distance(vc.begin(), it)
            << std::endl;
}
  • 结果
vc: 1 2 3 4 5 6
vc: 6 2 4 3 5 1
partition_point vc of noteven: 3
十五 github
  • 所有Demo 已上传github cplusplus
  • sorted-range_algorithm.cpp
十六 参考
C++ STL 标准模板库介绍与入门
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
C++ sort()排序详解
2301_80610560的博客
05-10 528
上面我们说到sort()函数可以自定义排序准则，以便满足不同的排序情况。使用sort()我们不仅仅可以从大到小排或者从小到大排，还可以按照一定的准则进行排序。比如说我们按照每个数的个位进行从大到小排序，我们就可以根据自己的需求来写一个函数作为排序的准则传入到sort()中。然后我们将这个cmp函数作为参数传入sort()中即可实现了上述排序需求。i<10;i++){}//输出结果：59 99 96 65 44 13 33 72 21 80return 0;
2024年C C++最新数据结构-排序篇_区间排序(3)，2024年最新花三分钟看完这篇文章你就懂了
2401_84978544的博客
05-13 930
2.1 原理：【算法思想】先将待排序记录序列分割成若干个“较稀疏的”子序列,分别进行直接插入排序。经过上述粗略调整,整个序列中的记录已经基本有序,最后再对全部记录进行一次直接插人排序。①首先选定记录间的距离为 di (i=1),在整个待排序记录序列中将所有间隔为 d1 的记录分成一组,进行组内直接插人排序。②然后取 i=i+1，记录间的距离为 di ( di < d(i-1) ), 在整个待排序记录序列中,将所有间隔为 di 的记录分成一组,进行组内直接插入排序。
C++11 算法 区间是否排序或局部排序
程序员Link
05-20 488
目录一 概述二 辅助函数三 std::is_sorted(C++11)四 std::is_sorted_until(C++11)五 Demo六 参考 一 概述 C++ 标准库中提供了很多算法，定义于头文件 < algorithm >。本文主要探究以下用于 区间是否排序或局部排序判断 的算法： is_sorted(C++11) 区间是否排序 is_sorted_until(C++11) 返回区间第一个破坏排序的元素 二 辅助函数 本文中Demo用到的辅助函数请参考此前文章 C++ 算法
C++使用sort函数对vector的任意区间排序(某一段元素排序)
m0_49252661的博客
10-08 5269
使用迭代器进行区间指定，注意start和end为前闭后开区间；sort函数内也可自行添加cmp比较函数，默认为从小到大排序。 #include <vector> #include <algorithm> using namespace std; int main(){ vector<int>input = { 1, 5, 2, 1, 3, 2, 5 }; //排序整个vector //sort(input.begin(), input.end()); //对任意区
C++练习题：指定类型与区间排序（函数模板）
Aibara的博客
12-12 570
SZTU面向对象实验题。 题目描述：现在有int、string、float，3种类型的数据需要排序 每次输入数据类型及n个数据，并指定排序区间[beg, end)，请你对该区间内的数据进行排序并输出 (可以使用系统排序函数)
区间排序2（c++）
abcjj_123的博客
08-01 408
区间排序2题目和满分代码
C++标准库详解与排序算法探讨
这本名为"The C++ Standard Library"的著作，由Josuttis撰写，是一本自修教材和参考工具书，专为C++程序员设计，详细讲解了C++标准库的各个方面。 章节9.9探讨了排序算法，这是程序设计中的关键操作，对数据进行...
C++实现各类排序算法实例
weixin_67948248的博客
04-29 465
对常见的各类算法收集总结，C++实现
C++快速排序算法及例子
12-23
快速排序算法是计算机科学中一种非常高效的排序算法，由C. A. R. Hoare在1960年提出。其基本思想是通过一趟排序将待排...快速排序算法因其优秀的平均性能，广泛应用于各种实际场景，包括编程语言的标准库排序函数中。
区间数排序方法评述
03-12
区间数排序方法评述，孙海龙，姚卫星，将任意两个区间数在数轴上的可能位置关系粗略划分为13种情形，并从确定性角度和基于度的角度出发，详细分析了目前已有的区间数排�
C++排序算法全集.rar
02-16
C++中可以使用两个指针，一个指向已排序区间的末尾，一个遍历未排序区间，时间复杂度为O(n^2)，但在部分有序的情况下表现良好。 4. 快速排序（Quick Sort）：由Lomuto或Hoare分区方案实现，选取一个基准值，将数组...
STL算法之heap算法，已排序区间算法
RGBMarco的博客
07-29 497
// 1. sort() 将区间元素以谓词方式排序 // 2. stable_sort() sort()并保持区间元素的稳定性 // 3. partial_sort() 以谓词找到前[beg,mid) // 4. partial_sort_copy() 将区间1的排序结果复制到区间2 // 5. nth_element() 将区间前n个元素排序 // 6. make_heap() 将区间元
LeetCode - 56. 合并区间（排序算法）
your_棒棒糖的博客
12-06 197
合并区间 思路一：排序 class Solution { public int[][] merge(int[][] intervals) { if (intervals.length == 0) { return new int[0][2]; } Arrays.sort(intervals, new Comparator<int[]>() { public int compare(in.
每日学习笔记：C++ STL算法之已排序区间算法
Jane_Yih的博客
08-06 692
C++ STL算法之处理已排序的区间的算法
C++ STL（第二十一篇：算法-- 应用于有序区间的算法）
weixin_39640298的博客
05-05 622
1、概述 有序区间，顾名思义就是区间内的元素都是经过排序之后的。对于这种类型的区间，有一系列的算法。今天就对这种区间的算法进行整理。 2、includes 判断序列 S2 是否 “涵盖于” 序列 S1，所谓涵盖，意思是 “S2 的每一个元素都出现于 S1”。代码如下： template<class InputIterator1, class InputIterator2> bool i...
c++算法--区间dp
NOI RP++
04-30 2113
区间dp算法
gesp(C++四级)（14）洛谷：B4041：[GESP202409 四级] 区间排序
最新发布
王老师青少年编程
01-11 1294
gesp(C++四级)（14）洛谷：B4041：[GESP202409 四级] 区间排序
6G.区间或和（C++）
Chilan_Yuk的博客
02-14 564
区间或和（C++） 点击做题网站链接 题目描述 求a|(a+1)|(a+2)|…|(b-1)|b。 其中|表示按位或。 输入描述: 多组输入，每行两个数表示a和b 输出描述: 对于每组输入，输出一个数a|(a+1)|(a+2)|…|(b-1)|b。 示例1 输入 99 109 68 77 55 66 34 43 1111234 1114321 输出 111 79 127 47 1179647 备注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值