C++合并（按排序范围运行）

最新推荐文章于 2024-07-22 16:48:28 发布
最新推荐文章于 2024-07-22 16:48:28 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： C++ 文章标签： merge inplace_merge include set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_34884208/article/details/87919781
版权

一、merge

头文件algorithm

default (1)	
template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result);
custom (2)	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result, Compare comp);

合并已排序的范围

将排序范围[first1，last1]和[first2，last2）中的元素组合到从结果开始的新范围中，并对其所有元素进行排序。

使用operator <作为第一个版本比较元素，comp作为第二个版本。 两个范围内的元素必须按照相同的标准（操作符<或comp）进行排序。 结果范围也根据此进行排序。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result)
{
  while (true) {
    if (first1==last1) return std::copy(first2,last2,result);
    if (first2==last2) return std::copy(first1,last1,result);
    *result++ = (*first2<*first1)? *first2++ : *first1++;
  }
}

参数

  1. first1，last1
    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
  2. first2，last2
    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2，last2）。
  3. result
    将迭代器输出到存储结果组合范围的范围的初始位置。它的大小等于上述两个范围的总和。
  4. comp
    二进制函数，接受迭代器指向的两个类型的参数，并返回一个可转换为bool的值。返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

范围不得重叠。 两个输入范围中的元素应该可以分配给result指向的范围内的元素。它们也应具有可比性（运算符<for（1），comp with（2））。

返回值

一个迭代器，指向结果序列中的past-the-end元素。

// merge example
#include <iostream>     // std::cout
#include <algorithm>    // std::merge, std::sort
#include <vector>       // std::vector

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);

  std::sort (first,first+5);
  std::sort (second,second+5);
  std::merge (first,first+5,second,second+5,v.begin());

  std::cout << "The resulting vector contains:";
  for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

例外

如果任何元素比较，元素赋值或迭代器上的操作抛出，则抛出。请注意，无效参数会导致未定义的行为。

二、inplace_merge

头文件algorithm

default (1)	
template <class BidirectionalIterator>
  void inplace_merge (BidirectionalIterator first, BidirectionalIterator middle,
                      BidirectionalIterator last);
custom (2)	
template <class BidirectionalIterator, class Compare>
  void inplace_merge (BidirectionalIterator first, BidirectionalIterator middle,
                      BidirectionalIterator last, Compare comp);

合并连续排序的范围
合并两个连续的排序范围：[first，middle]和[middle，last），将结果放入组合的排序范围[first，last]。

使用operator <作为第一个版本比较元素，comp作为第二个版本。两个范围内的元素必须按照相同的标准（操作符<或comp）进行排序。结果范围也根据此进行排序。

该函数保留具有等效值的元素的相对顺序，第一个范围中的元素在第二个范围内的元素之前。

参数

  1. first
    双向迭代器到第一个排序序列中的初始位置进行合并。这也是存储合并范围的初始位置。
  2. middle
    到第二个排序序列的初始位置的双向迭代器，因为两个序列必须是连续的，所以匹配第一个序列的过去位置。
  3. last
    双向迭代器到第二个排序序列的过去位置。这也是存储合并范围的范围的过去位置。
  4. comp
    二进制函数，接受迭代器指向的两个类型的参数，并返回一个可转换为bool的值。返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

BidirectionalIterator应指向一个正确定义了swap的类型，它既
move-constructible又move-assignable。

返回值

没有

// inplace_merge example
#include <iostream>     // std::cout
#include <algorithm>    // std::inplace_merge, std::sort, std::copy
#include <vector>       // std::vector

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);
  std::vector<int>::iterator it;

  std::sort (first,first+5);
  std::sort (second,second+5);

  it=std::copy (first, first+5, v.begin());
     std::copy (second,second+5,it);

  std::inplace_merge (v.begin(),v.begin()+5,v.end());

  std::cout << "The resulting vector contains:";
  for (it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

复杂

如果有足够的额外内存可用，则在第一个和最后一个之间的距离为线性：执行N-1次比较，最多执行两次元素移动。
否则，最多为linearithmic：执行最多N * log（N）个元素比较（其中N是上面的距离），最多可执行多个元素交换。

例外

如果任何元素比较，元素交换（或移动）或迭代器上的操作抛出，则抛出。请注意，无效参数会导致未定义的行为。

三、include

头文件algorithm

template <class InputIterator1, class InputIterator2>
  bool includes ( InputIterator1 first1, InputIterator1 last1,
                  InputIterator2 first2, InputIterator2 last2 );

template <class InputIterator1, class InputIterator2, class Compare>
  bool includes ( InputIterator1 first1, InputIterator1 last1,
                  InputIterator2 first2, InputIterator2 last2, Compare comp );

测试排序范围是否包括另一个排序范围

如果排序范围[first1，last1]包含排序范围[first2，last2]中的所有元素，则返回true。

使用operator <作为第一个版本比较元素，comp作为第二个版本。 如果（！（a <b）&&！（b <a））或if（！comp（a，b）&&！comp（b，a）），则认为两个元素a和b是等价的。

范围内的元素应按照相同的标准（操作符<或comp）进行排序。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2>
  bool includes (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2)
{
  while (first2!=last2) {
    if ( (first1==last1) || (*first2<*first1) ) return false;
    if (!(*first1<*first2)) ++first2;
    ++first1;
  }
  return true;
}

参数

  1. first1，last1
    将迭代器输入到第一个排序序列的初始位置和最终位置（测试它是否包含第二个序列）。使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
  2. first2，last2
    将迭代器输入到第二个排序序列的初始位置和最终位置（测试它是否包含在第一个序列中）。使用的范围是[first2，last2）。
  3. comp
    二进制函数，接受两个元素作为参数（两个序列中的每个序列中的一个，顺序相同），并返回一个可转换为bool的值。返回的值表示作为第一个参数传递的元素是否被认为是在它定义的特定严格弱顺序中的第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

如果范围[first2，last2]中的每个元素都包含在[first1，last1]范围内，则返回true，否则返回false。
【C++ 98】
如果[first2，last2）是空范围，则结果未指定。
【C++ 11】
如果[first2，last2）为空范围，则该函数返回true。

// includes example
#include <iostream>     // std::cout
#include <algorithm>    // std::includes, std::sort

bool myfunction (int i, int j) { return i<j; }

int main () {
  int container[] = {5,10,15,20,25,30,35,40,45,50};
  int continent[] = {40,30,20,10};

  std::sort (container,container+10);
  std::sort (continent,continent+4);

  // using default comparison:
  if ( std::includes(container,container+10,continent,continent+4) )
    std::cout << "container includes continent!\n";

  // using myfunction as comp:
  if ( std::includes(container,container+10,continent,continent+4, myfunction) )
    std::cout << "container includes continent!\n";

  return 0;
}

在这里插入图片描述

复杂

在两个范围内最多为两倍距离的线性：执行最多2 *（count1 + count2）-1次比较（其中countX是firstX和lastX之间的距离）。

数据竞赛

访问两个范围中的一些（或所有）对象（最多两次）。

例外

如果任何元素比较（或调用comp）抛出或迭代器上的任何操作抛出，则抛出。
请注意，无效参数会导致未定义的行为。

四、set_union

头文件algorithm

default (1)	
template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result);
custom (2)	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result, Compare comp);

联合两个排序范围

构造一个从result指向的位置开始的排序范围，其中包含两个排序范围[first1，last1]和[first2，last2）的set union。

两组的并集由存在于任一组中的元素形成，或者由两者组成。 第二个范围中具有第一个范围中的等效元素的元素不会复制到结果范围。

使用operator <作为第一个版本比较元素，comp作为第二个版本。 如果（！（a <b）&&！（b <a））或if（！comp（a，b）&&！comp（b，a）），则认为两个元素a和b是等价的。

范围中的元素应根据相同的标准（运算符<或comp）进行排序。 结果范围也根据此进行排序。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result)
{
  while (true)
  {
    if (first1==last1) return std::copy(first2,last2,result);
    if (first2==last2) return std::copy(first1,last1,result);

    if (*first1<*first2) { *result = *first1; ++first1; }
    else if (*first2<*first1) { *result = *first2; ++first2; }
    else { *result = *first1; ++first1; ++first2; }
    ++result;
  }
}

参数

  1. first1，last1
    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
  2. first2，last2
    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2，last2）。
  3. result
    将迭代器输出到存储结果序列的范围的初始位置。
    指向的类型应支持从其他范围分配元素的值。
  4. comp
    二进制函数，它接受输入迭代器指向的两个类型的参数，并返回一个可转换为bool的值。返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

范围不得重叠。

返回值

构造范围末尾的迭代器。

// set_union example
#include <iostream>     // std::cout
#include <algorithm>    // std::set_union, std::sort
#include <vector>       // std::vector

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
  std::vector<int>::iterator it;

  std::sort (first,first+5);     //  5 10 15 20 25
  std::sort (second,second+5);   // 10 20 30 40 50

  it=std::set_union (first, first+5, second, second+5, v.begin());
                                               // 5 10 15 20 25 30 40 50  0  0
  v.resize(it-v.begin());                      // 5 10 15 20 25 30 40 50

  std::cout << "The union has " << (v.size()) << " elements:\n";
  for (it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

五、set_intersection

头文件algorithm

default (1)	
template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result);
custom (2)	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result, Compare comp);

两个排序范围的交点

构造一个从result指向的位置开始的排序范围，其中包含两个排序范围[first1，last1]和[first2，last2）的集合交集。

两组的交集仅由两组中存在的元素形成。 函数复制的元素始终来自第一个范围，顺序相同。

使用operator <作为第一个版本比较元素，comp作为第二个版本。 如果（！（a <b）&&！（b <a））或if（！comp（a，b）&&！comp（b，a）），则认为两个元素a和b是等价的。

范围中的元素应根据相同的标准（运算符<或comp）进行排序。 结果范围也根据此进行排序。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result)
{
  while (first1!=last1 && first2!=last2)
  {
    if (*first1<*first2) ++first1;
    else if (*first2<*first1) ++first2;
    else {
      *result = *first1;
      ++result; ++first1; ++first2;
    }
  }
  return result;
}

参数

  1. first1，last1
    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
  2. first2，last2
    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2，last2）。
  3. result
    将迭代器输出到存储结果序列的范围的初始位置。
    指向类型应支持从第一个范围分配元素的值。
  4. comp
    二进制函数，它接受输入迭代器指向的两个类型的参数，并返回一个可转换为bool的值。返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

范围不得重叠。

返回值

构造范围末尾的迭代器。

// set_intersection example
#include <iostream>     // std::cout
#include <algorithm>    // std::set_intersection, std::sort
#include <vector>       // std::vector

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
  std::vector<int>::iterator it;

  std::sort (first,first+5);     //  5 10 15 20 25
  std::sort (second,second+5);   // 10 20 30 40 50

  it=std::set_intersection (first, first+5, second, second+5, v.begin());
                                               // 10 20 0  0  0  0  0  0  0  0
  v.resize(it-v.begin());                      // 10 20

  std::cout << "The intersection has " << (v.size()) << " elements:\n";
  for (it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

六、set_difference

头文件algorithm

default (1)	
template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result);
custom (2)	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result, Compare comp);

两个排序范围的差异

构造从结果指向的位置开始的排序范围，其中排序范围[first1，last1]的设置差异相对于排序范围[first2，last2]。

两组的差异由第一组中存在的元素形成，但不存在于第二组中。函数复制的元素始终来自第一个范围，顺序相同。

对于支持多次出现的值的容器，差异包括与第一个范围中一样多的给定值的出现，减去第二个保留顺序中的匹配元素的数量。

请注意，这是一个方向性操作 - 对于对称等效，请参阅set_symmetric_difference。

使用operator <作为第一个版本比较元素，comp作为第二个版本。如果（！（a <b）&&！（b <a））或if（！comp（a，b）&&！comp（b，a）），则认为两个元素a和b是等价的。

范围中的元素应根据相同的标准（运算符<或comp）进行排序。结果范围也根据此进行排序。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result)
{
  while (first1!=last1 && first2!=last2)
  {
    if (*first1<*first2) { *result = *first1; ++result; ++first1; }
    else if (*first2<*first1) ++first2;
    else { ++first1; ++first2; }
  }
  return std::copy(first1,last1,result);
}

参数

  1. first1，last1
    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
  2. first2，last2
    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2，last2）。
  3. result
    将迭代器输出到存储结果序列的范围的初始位置。
    指向类型应支持从第一个范围分配元素的值。
  4. comp
    二进制函数，它接受输入迭代器指向的两个类型的参数，并返回一个可转换为bool的值。返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

范围不得重叠。

返回值

构造范围末尾的迭代器。

// set_difference example
#include <iostream>     // std::cout
#include <algorithm>    // std::set_difference, std::sort
#include <vector>       // std::vector

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
  std::vector<int>::iterator it;

  std::sort (first,first+5);     //  5 10 15 20 25
  std::sort (second,second+5);   // 10 20 30 40 50

  it=std::set_difference (first, first+5, second, second+5, v.begin());
                                               //  5 15 25  0  0  0  0  0  0  0
  v.resize(it-v.begin());                      //  5 15 25

  std::cout << "The difference has " << (v.size()) << " elements:\n";
  for (it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

七、set_symmetric_difference

头文件algorithm

default (1)	
template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
                                           InputIterator2 first2, InputIterator2 last2,
                                           OutputIterator result);
custom (2)	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class Compare>
  OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
                                           InputIterator2 first2, InputIterator2 last2,
                                           OutputIterator result, Compare comp);

两个排序范围的对称差异

构造一个从result指向的位置开始的排序范围，其中包含两个排序范围[first1，last1]和[first2，last2）的设置对称差异。

两组的对称差异由一组中存在的元素形成，而另一组中不存在。 在每个范围中的等效元素中，丢弃的那些是在调用之前以现有顺序出现的那些元素。 还会为复制的元素保留现有顺序。

使用operator <作为第一个版本比较元素，comp作为第二个版本。 如果（！（a <b）&&！（b <a））或if（！comp（a，b）&&！comp（b，a）），则认为两个元素a和b是等价的。

范围中的元素应根据相同的标准（运算符<或comp）进行排序。 结果范围也根据此进行排序。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
                                           InputIterator2 first2, InputIterator2 last2,
                                           OutputIterator result)
{
  while (true)
  {
    if (first1==last1) return std::copy(first2,last2,result);
    if (first2==last2) return std::copy(first1,last1,result);

    if (*first1<*first2) { *result=*first1; ++result; ++first1; }
    else if (*first2<*first1) { *result = *first2; ++result; ++first2; }
    else { ++first1; ++first2; }
  }
}

参数

  1. first1，last1
    将迭代器输入到第一个排序序列的初始位置和最终位置。使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
  2. first2，last2
    将迭代器输入到第二个排序序列的初始位置和最终位置。使用的范围是[first2，last2）。
  3. result
    将迭代器输出到存储结果序列的范围的初始位置。
    指向的类型应支持从其他范围分配元素的值。
  4. comp
    二进制函数，它接受输入迭代器指向的两个类型的参数，并返回一个可转换为bool的值。返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

范围不得重叠。

返回值

构造范围末尾的迭代器。

// set_symmetric_difference example
#include <iostream>     // std::cout
#include <algorithm>    // std::set_symmetric_difference, std::sort
#include <vector>       // std::vector

int main () {
  int first[] = {5,10,15,20,25};
  int second[] = {50,40,30,20,10};
  std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
  std::vector<int>::iterator it;

  std::sort (first,first+5);     //  5 10 15 20 25
  std::sort (second,second+5);   // 10 20 30 40 50

  it=std::set_symmetric_difference (first, first+5, second, second+5, v.begin());
                                               //  5 15 25 30 40 50  0  0  0  0
  v.resize(it-v.begin());                      //  5 15 25 30 40 50

  std::cout << "The symmetric difference has " << (v.size()) << " elements:\n";
  for (it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

WilliamX2020
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用c++写一个合并算法
weixin_42613018的博客
12-21 340
归并排序是一种分治算法，它将一个序列递归地分成两半，然后将它们排序，最后将它们合并在一起。下面是一个使用 C 语言实现的归并排序的示例： ``` #include <stdio.h> #include <stdlib.h> // 合并两个已排序的数组 a[p..q] 和 a[q+1..r] void merge(int a[], int p, int q, int r) {...
合并排序算法-c++
扎扎实实写代码的专栏
11-03 3075
参考来源：http://www.cnblogs.com/yangecnu/p/Introduce-Merge-Sort.html 合并排序，顾名思义，就是通过将两个有序的序列合并为一个大的有序的序列的方式来实现排序。合并排序是一种典型的分治算法：首先将序列分为两部分，然后对每一部分进行循环递归的排序，然后逐个将结果进行合并。 合并排序最大的优点是它的时间复杂度为O(nlgn)，这个
用C++实现合并排序
04-18
利用分治法的合并排序实现数组的排序，根据算法导论第二章编写
C++算法之合并排序法的代码
bu40979的博客
08-16 584
如下代码内容是关于C++算法之合并排序法的代码，应该是对大伙有些用。 void merge_sort(int array[], int length) { if(NULL == array || 0 == length) return ; _merge_sort(array, 0, length-1); } b）进行merge函数迭代操作 void _merge_sort(int a...
C++区间合并
最新发布
m0_62112384的博客
07-22 121
C++区间合并
C++链表合并
weixin_42347067的博客
10-03 725
C++链表合并
区间合并(c++)
m0_74012728的博客
04-01 332
给定 n 个区间 [li,ri] ，要求合并所有有交集的区间。 注意如果在端点处相交，也算有交集。 输出合并完成后的区间个数。 例如：[1,3] 和 [2,6] 可以合并为一个区间 [1,6] 。
算法入门＜一＞：C++各种排序算法详解及示例源码
欧特GO
04-28 1926
算法入门＜一＞：C++各种排序算法详解及示例源码
数据结构C++代码（排序）
11-10
当数据范围较小且分布均匀时，桶排序可以达到线性时间复杂度O(n + k)，其中k是桶的数量。 希尔排序（Shell Sort）是插入排序的优化版本，通过设置一个增量序列，使得元素在更远的距离上进行插入排序，从而减少比较...
c++十大排序——归并排序
yang_yi520的博客
05-27 3634
算法基本知识铺垫 有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下： 1、稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 仍然在 b 的前面，则为稳定排序 2、非稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 可能不在 b 的前面，则为非稳定排序。 3、原地排序：原地排序就是指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储 空间进行比较和交换的数据排序。 4、非原地排序：需要利用额外的数组来辅助排
c++实现归并排序与快速排序运行时间比较
10-07
在编程领域，排序算法是基础且重要的组成部分，用于组织数据以...在C++中，我们可以根据具体应用场景选择合适的排序算法，而通过实际运行时间的比较，可以帮助我们更好地理解这两种算法在不同数据规模下的性能表现。
归并排序的c++代码
06-08
基于visual studio2010，的程序开发，...............................................................................................
区间合并（C++)
2202_75394720的博客
07-26 514
给定 nn 个区间 [li,ri][li,ri]，要求合并所有有交集的区间。注意如果在端点处相交，也算有交集。输出合并完成后的区间个数。例如：[1,3][1,3] 和 [2,6][2,6] 可以合并为一个区间 [1,6][1,6]。
区间合并（C++）
Annabel_CM的博客
07-15 3447
基本思想 端点相交也算 基本模板 // 将所有存在交集的区间合并 void merge(vector<PII> &segs) { vector<PII> res; sort(segs.begin(), segs.end()); int st = -2e9, ed = -2e9; for (auto seg : segs) if (ed < seg.first) { if.
区间合并模板题
cwtnice的博客
08-14 313
原题链接： AcWing 803.区间合并 关键词： 区间合并 给定 n 个区间 [li,ri]，要求合并所有有交集的区间。 注意如果在端点处相交，也算有交集。 输出合并完成后的区间个数。 例如：[1,3] 和 [2,6] 可以合并为一个区间 [1,6]。 输入格式 第一行包含整数 n。 接下来 n 行，每行包含两个整数 l 和 r。 输出格式 共一行，包含一个整数，表示合并区间完成后的区间个数。 数据范围 1≤n≤100000, −109≤li≤ri≤109 输入样例： 5 1 2 2 4 5 6 7 8
C++算法之区间合并
qq_74729280的博客
05-11 1508
本文介绍区间合并这一基础算法，介绍常规的做法以及模板通常区间合并是给定数个区间，想要将有交集的区间合并成一个区间如下要求，就是通常遇见区间合并问题的简化给定 n 个区间 [l,r]，要求合并所有有交集的区间。注意如果在端点处相交，也算有交集。介绍了区间合并算法的解决方法，同时给了俩道例题实现了区间合并算法推荐学习博客。
C++合并区间
qq_62916508的博客
07-13 1064
通过对起始时间进行排序，并依次比较相邻的两个区间，我们可以找到所有重叠的区间，并将它们合并成一个大区间。要解决这个问题，我们需要找到所有重叠的区间，并将它们合并成一个大区间。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。例如，假设集合为[[1,3],[2,6],[8,10],[15,18]]，则合并后的结果为[[1,6],[8,10],[15,18]]。输入：[[1,3],[2,6],[8,10],[15,18]]输出：[[1,6],[8,10],[15,18]]
C++与数据合并
JuniorChestnut的博客
09-15 1182
一、字符串与字符串合并 1. 这个比较简单： （1）string str1 = "hello"; string str2 = "world"; string str3 = str1 + ' '+ str2; =hello world 2. 对于字符数组，可以直接转化为string类的字符串： char name[40] = "I LOVE SOMETHING YOU DONT LIKE"; string tempName = name; 然后直接使用1的方式合并； 二、字符串与非字符串的合并 1.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值