C++ STL概念之算法

sort

| default (1) | template <class RandomAccessIterator> void sort (RandomAccessIterator first, RandomAccessIterator last); |

custom (2) template <class RandomAccessIterator, class Compare> void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

**作用：**用于对容器中的元素进行排序。它通常采用快速排序算法作为基础算法，但是标准并没有规定必须使用快速排序，实际的实现依赖于库的具体实现。一些实现可能会为了提高效率或稳定性使用诸如归并排序、堆排序或其他排序算法的混合版本。

1.default (1)：
template <class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);
default(1) 形式接受两个参数，它们是随机访问迭代器 first 和 last，分别表示要排序序列的起始位置和结束位置（注意：指向序列末尾的元素的 下一个位置，即 half-open）。这个版本使用 operator< 来比较元素，因此会按 从小到大 的顺序对元素进行排序。

2.custom (2)：
template <class RandomAccessIterator, class Compare>
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
custom(2) 形式除了接受随机访问迭代器 first 和 last 外，还接受一个额外的参数 comp，这个参数是一个可调用对象（例如函数或函数对象），用于比较元素的顺序。如果 comp(a, b) 返回 true，那么元素 a 会被放在元素 b 的前面。

stable_sort

复制代码
template <class RandomAccessIterator>
  void stable_sort ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void stable_sort ( RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp );
作用：和sort一样，用于对容器中的元素进行排序。但是区别在于stable_sort能够保持相同元素的原有顺序。

1.第一种形式（不带比较函数）
template <class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
这个重载版本的 stable_sort 函数接受两个参数，它们是随机访问迭代器 first 和 last。它按照元素类型的 operator< 来排序，从而保证元素以升序排列，并保持相等元素的原有顺序。

2.第二种形式（带比较函数）
template <class RandomAccessIterator, class Compare>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
这个重载版本接受三个参数：随机访问迭代器 first 和 last，以及一个可调用的比较对象 comp。这个比较函数或函数对象定义了排序中元素的顺序。如果 comp(a, b) 为 true，则元素 a 会在排序后出现在 b 的前面，并且这个版本同样保持了相等元素的原有顺序。

reverse

reverse功能

swap

| non-array (1) | template <class T> void swap (T& a, T& b) noexcept (is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value); |

array (2) template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept (noexcept(swap(*a,*b)));

swap 是一个用于交换两个对象内容的非常有用的函数模板，它是标准模板库（STL）的一部分。swap 可以作用于几乎所有类型的对象，包括基础数据类型、STL 容器、用户自定义类型等，只要对象类型支持复制或移动操作。

1.非数组类型的 swap：
template <class T> void swap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value);
这里 T 代表任意非数组类型。函数接受两个类型为 T 的对象的引用 a 和 b 并交换它们的值。该函数声明为 noexcept 表明如果类型 T 对象的移动构造和移动赋值运算符都不会抛出异常，那么 swap 函数也不会抛出异常。

2.数组类型的 swap：
template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a,*b)));
这里 T 代表数组元素类型，N 是数组的大小。这个函数模板接受两个同类型、同大小的数组的引用 a 和 b 并交换它们的内容。这个重载版本保证了对于数组中的每个元素调用 swap 都不会抛出异常时，那么这个数组的 swap 版本同样不会抛出异常。

swap建议：

在C++98中，建议使用的是容器中的成员方法swap，

而在C++11中swap 函数能提供高效的值交换，这是因为它们利用了移动语义（对于非数组类型的对象）和元素级别的交换（对于数组类型）。

max / min

max

| default (1) | template <class T> const T& max (const T& a, const T& b); |
| custom (2) | template <class T, class Compare> const T& max (const T& a, const T& b, Compare comp); |

initializer list (3) template <class T> T max (initializer_list<T> il); template <class T, class Compare> T max (initializer_list<T> il, Compare comp);

第一种形式（默认）:
template <class T> 
const T& max(const T& a, const T& b);
在两个参数 a 和 b 中返回最大的一个。这个版本默认使用类型 T 的 operator< 作为比较依据。

第二种形式（自定义）：
template <class T, class Compare> 
const T& max(const T& a, const T& b, Compare comp);
在两个参数 a 和 b 中返回最大的一个。通过使用自定义的比较对象 comp 来决定哪个元素是最大。

第三种形式（初始化列表）：
template <class T>
T max(initializer_list<T> il);
在 initializer_list<T> 中返回最大的元素，这个版本默认使用类型 T 的 operator< 作为比较依据。

第四种形式（初始化列表和自定义）：
template <class T, class Compare>
T max(initializer_list<T> il, Compare comp);
在 initializer_list<T> 中返回最大的元素，通过使用自定义的比较对象 comp 来决定哪个元素是最大。

min

| default (1) | template <class T> const T& min (const T& a, const T& b); |
| custom (2) | template <class T, class Compare> const T& min (const T& a, const T& b, Compare comp); |

initializer list (3) template <class T> T min (initializer_list<T> il); template <class T, class Compare> T min (initializer_list<T> il, Compare comp);

1.第一种形式（默认）：
template <class T> 
const T& min(const T& a, const T& b);
在两个参数 a 和 b 中返回最小的一个。这个版本默认使用类型 T 的 operator< 作为比较依据。

2.第二种形式（自定义）：
template <class T, class Compare> 
const T& min(const T& a, const T& b, Compare comp);
在两个参数 a 和 b 中返回最小的一个。通过使用自定义的比较函数 comp 来决定哪个元素是最小的。

3.第三种形式（初始化列表）：
template <class T> 
T min(initializer_list<T> il);
在 initializer_list<T> 中返回最小的元素，这个版本默认使用类型 T 的 operator< 作为比较依据。

4.第四种形式（初始化列表和自定义）：
template <class T, class Compare> T min(initializer_list<T> il, Compare comp);
在 initializer_list<T> 中返回最小的元素，通过使用自定义的比较函数 comp 来决定哪个元素是最小的。

find

复制代码
template <class InputIterator, class T>
   InputIterator find (InputIterator first, InputIterator last, const T& val);
std::find 函数用于在范围 [first, last) 中寻找值为 val 的第一个元素。

这里的参数说明如下：

first 和 last：表示要搜索的范围，即搜索起始位置 first 和结束位置 last 的迭代器。这个范围包含起始位置，但不包含结束位置。

val：需要搜索的值。

返回值是一个迭代器，指向找到的第一个等于 val 的元素。如果在序列中没有找到这样的元素，那么返回的迭代器等于 last。

next_permutation / prev_permutation

next_permutation

| default (1) | template <class BidirectionalIterator> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last); |

custom (2) template <class BidirectionalIterator, class Compare> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp);

这个函数用于生成给定范围 [first, last) 的下一个字典序排列，并且如果存在这样的排列，函数返回 true，否则（如果当前排列已经是最大的字典序排列），它会将序列重新排列为最小的字典序排列并返回 false。

1.默认形式：
template <class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);
在不提供自定义比较函数的情况下，使用类型 T 的 operator< 作为比较逻辑。

2.自定义形式：
template <class BidirectionalIterator, class Compare>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
接受一个额外的比较函数 comp，可以自定义元素间的比较规则。

prev_permutation

| default (1) | template <class BidirectionalIterator> bool prev_permutation (BidirectionalIterator first, BidirectionalIterator last ); |

custom (2) template <class BidirectionalIterator, class Compare> bool prev_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp);

它与 std::next_permutation 类似，不过它是用来生成给定范围 [first, last) 的前一个字典序排列。如果存在这样的排列，函数返回 true；否则（当当前排列已经是最小的字典序排列），它会将序列重排为最大的字典序排列并返回 false。

1.默认形式：
template <class BidirectionalIterator>
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
这个函数不接受比较函数，它默认使用类型 T 的 operator< 作为比较逻辑。

2.自定义形式：
template <class BidirectionalIterator, class Compare>
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
这个函数接受一个额外的比较函数 comp，可以让用户自定义元素间的比较规则。

binary_search(二分查找)

| default (1) | template <class ForwardIterator, class T> bool binary_search (ForwardIterator first, ForwardIterator last, const T& val); |

custom (2) template <class ForwardIterator, class T, class Compare> bool binary_search (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);

1.默认版本：
template <class ForwardIterator, class T>
bool binary_search(ForwardIterator first, ForwardIterator last, const T& val);
这个版本使用元素类型的 operator< 来比较元素。

2.自定义比较版本：
template <class ForwardIterator, class T, class Compare>
bool binary_search(ForwardIterator first, ForwardIterator last, const T& val, Compare comp);
这个版本允许用户指定一个自定义比较函数 comp。

upper_bound / lower_bound(上下界)

upper_bound

| default (1) | template <class ForwardIterator, class T> ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& val); |

custom (2) template <class ForwardIterator, class T, class Compare> ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);

用于在已排序范围内找到第一个大于给定值 val 的元素。这样的搜索过程是二分查找的一种应用，可以高效地在对数时间复杂度内完成查找。

1.默认版本：
template <class ForwardIterator, class T>
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& val);
此版本使用元素的 < 操作符作为比较依据。

2.自定义比较版本：
template <class ForwardIterator, class T, class Compare>
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& val, Compare comp);
此版本允许用户提供自定义的比较函数或对象 comp，用于比较元素。

lower_bound

| default (1) | template <class ForwardIterator, class T> ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val); |

custom (2) template <class ForwardIterator, class T, class Compare> ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);

默认版本（1）
template <class ForwardIterator, class T>
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val);
这个版本的lower_bound使用元素的<操作符来比较元素和给定值。它从first到last（不包含last）查找第一个不小于val的元素，并返回一个指向它的迭代器。如果所有元素都小于val，则返回last。

自定义比较版本（2）
template <class ForwardIterator, class T, class Compare>
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);
这个版本允许用户指定一个自定义比较函数或函数对象comp，而不是使用默认的<操作符。这使得用户可以定义更复杂的排序逻辑。比如，可以根据元素的某个特定字段进行查找，或使用不同于默认的比较规则。

set_union / set_intersection / set_difference

set_union

| 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);

用于计算两个已排序区间（集合）的并集，也就是包含两个区间中所有元素的新区间，同时去除重复元素，结果也是排序的。

默认版本（1）
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result);
这个版本使用元素的<操作符来进行比较。它遍历两个输入区间（第一个从first1到last1，第二个从first2到last2），然后将结果写入从result开始的输出区间。如果两个区间中存在相等的元素，则只复制第一个区间中的该元素到输出区间。结果区间中的元素会按升序排序。

自定义比较版本（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);
这个版本允许用户通过comp参数提供一个自定义的比较函数，以便在比较元素时使用。这让用户可以自定义元素比较的规则，而不是仅依赖于元素类型的<操作符。如果元素类型是自定义的，或者需要按不同于默认<操作符的方式来比较元素，这个版本就特别有用。

set_intersection

| 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);

用于在C++中计算两组已排序序列的交集。 set_intersection是标准模板库（STL）的一部分，主要用于找出两个区间共同的元素。

默认版本（1）
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2,
                                OutputIterator result);
这个版本利用元素类型自带的<比较操作符来进行元素间的比较。这意味着序列中的元素类型必须支持<操作符。函数通过比较两个序列发现共有的元素，并将这些元素复制到结果序列中。结果序列中不会出现重复元素，且元素会按照升序排列。如果两个输入序列中的元素均存在，则只会复制第一个序列中的相应元素到结果序列。

自定义比较版本（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);
这个版本与默认版本相似，但给用户提供了一个comp参数，以便自定义元素间的比较规则。通过comp，用户可以指定一个比较函数或函数对象，用来代替默认的<比较操作符。这使用户能够根据自定义的逻辑进行比较，例如，按照元素的某一特定属性或更复杂的条件进行排序和比较。

set_difference

| 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);

用于计算两个已排序序列（集合）的差集。

默认版本（1）
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
                              InputIterator2 first2, InputIterator2 last2,
                              OutputIterator result);
这个版本使用元素类型的<操作符进行比较。它构造一个新的序列，该序列包含在第一个序列中存在，但在第二个序列中不存在的元素，这个序列就是两个输入序列的差集。结果序列中的元素会按升序排序。

自定义比较版本（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);
这个版本提供了一个comp参数，允许用户自定义元素间的比较规则。所谓自定义比较规则，就是用户可以指定一个比较函数或函数对象，用于取代默认的<操作符进行元素比较。这个版本可以帮助用户处理更复杂的比较，比如基于元素字段、或者要求排序规则和默认的<操作符不同的情况。

C++ STL概念之 算法

sort

stable_sort

reverse

swap

swap建议：

max / min

find

next_permutation / prev_permutation

binary_search(二分查找)

upper_bound / lower_bound(上下界)

默认版本（1）

自定义比较版本（2）

set_union / set_intersection / set_difference

set_union

默认版本（1）

自定义比较版本（2）

set_intersection

默认版本（1）

自定义比较版本（2）

set_difference

默认版本（1）

自定义比较版本（2）

C++ STL概念之算法