// STL算法.cpp : 定义控制台应用程序的入口点。
//最后修改时间：2018/02/13，测试平台 vs2017
/*
STL六个部分
容器：见相关工程，学习上有两个难点：双端队列的实现细节，RBtree实现细节
分配器：allocator,学习版本是侯捷的书，sgi新版本增了继承层次。内存学习的高级主题
算法：本工程，容器无关的算法
适配器：容器/仿函数。基于容器实现的栈，单链表等
迭代器：最好是参考网站内容http://zh.cppreference.com/w/cpp/iterator
仿函数：无对应工程，比较简单，熟悉已有的小函数可以省得造轮子。
*/
//本页完成的是 3.算法。部分C++17的例子尚未提供
//泛型算法及相关辅助函数
#include "stdafx.h"
#include <iterator>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include <list>
#include <iterator>
#include <experimental\filesystem>
#include <array>
#include <functional>
#include <thread>
#include <chrono>
#include <cctype>
#include <random>
#include <forward_list>
#include <cstdlib>
#include <climits>
using namespace std;
template<typename Container>
bool in_quote(const Container& cont, const std::string& s)
{
return std::search(cont.begin(), cont.end(), s.begin(), s.end()) != cont.end();
}
template <class Container, class Size, class T>
bool consecutive_values(const Container& c, Size count, const T& v)
{
return std::search_n(std::begin(c), std::end(c), count, v) != std::end(c);
}
template<class ForwardIt>
void selection_sort(ForwardIt begin, ForwardIt end)
{
for (ForwardIt i = begin; i != end; ++i)
std::iter_swap(i, std::min_element(i, end));
}
template <class ForwardIt>
void quicksort(ForwardIt first, ForwardIt last)
{
if (first == last) return;
auto pivot = *std::next(first, std::distance(first, last) / 2);
ForwardIt middle1 = std::partition(first, last,
[pivot](const auto& em) { return em < pivot; });
ForwardIt middle2 = std::partition(middle1, last,
[pivot](const auto& em) { return !(pivot < em); });
quicksort(first, middle1);
quicksort(middle2, last);
}
template<class ForwardIt, class T, class Compare = std::less<>>
ForwardIt binary_find(ForwardIt first, ForwardIt last, const T& value, Compare comp = {})
{
// 注意：类型 T 和 Forward 解引用后的类型都必须可隐式转换为
// 用于 Compare 的 Type1 和 Type2 。
// 这严格于 lower_bound 要求（见上述）
first = std::lower_bound(first, last, value, comp);
return first != last && !comp(value, *first) ? first : last;
}
template<class Iter>
void merge_sort(Iter first, Iter last)
{
if (last - first > 1) {
Iter middle = first + (last - first) / 2;
merge_sort(first, middle);
merge_sort(middle, last);
std::inplace_merge(first, middle, last);
}
}
//例子全部来源于cppreference
int main()
{
/*泛型算法，超过100个,分为
*只读算法
*写容器算法
*重排算法
*/
////////////////////////////////////////
//只读算法/////////////////////////////
////////////////////////////////////////
{
//any_of,all_of,none_of
//检查一定范围之内，是否全部、存在或不存在元素使得谓词为true
{
std::vector<int,allocator<int>> v(10, 2);
std::partial_sum(v.cbegin(), v.cend(), v.begin());//2,4,6....20
std::cout << "Among the numbers: ";
std::copy(v.cbegin(), v.cend(), std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
if (std::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; })) {
std::cout << "All numbers are even\n";
}
if (std::none_of(v.cbegin(), v.cend(), std::bind(std::modulus<int>(),
std::placeholders::_1, 2))) {
std::cout << "None of them are odd\n";
}
struct DivisibleBy
{
const int d;
DivisibleBy(int n) : d(n) {}
bool operator()(int n) const { return n % d == 0; }
};
if (std::any_of(v.cbegin(), v.cend(), DivisibleBy(7))) {
std::cout << "At least one number is divisible by 7\n";
}
}
//for_each将一个函数应用于某一范围的元素
//返回值是参数3，可执行函数std::move(f)
{
std::vector<int> nums{ 3, 4, 2, 8, 15, 267 };
auto print = [](const int& n) { std::cout << " " << n; };
std::cout << "before:";
std::for_each(nums.begin(), nums.end(), print);
std::cout << ‘\n‘;
std::for_each(nums.begin(), nums.end(), [](int &n) { n++; });
// 对每个数调用 Sum::operator()
struct Sum
{
Sum() : sum{ 0 } { }
void operator()(int n) { sum += n; }
int sum;
};
Sum s = std::for_each(nums.begin(), nums.end(), Sum());
std::cout << "after: ";
std::for_each(nums.begin(), nums.end(), print);
std::cout << ‘\n‘;
std::cout << "sum: " << s.sum << ‘\n‘;
}
//for_each_n应用函数对象到序列的首 n 个元素
//count
//count_if
{
std::vector<int> v{ 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 };
// 确定 std::vector 中有多少个整数匹配目标值。
int target1 = 3;
int target2 = 5;
int num_items1 = std::count(v.begin(), v.end(), target1);
int num_items2 = std::count(v.begin(), v.end(), target2);
std::cout << "number: " << target1 << " count: " << num_items1 << ‘\n‘;
std::cout << "number: " << target2 << " count: " << num_items2 << ‘\n‘;
// 用 lambda 表达式计量能被 3 整除的元素数。
int num_items3 = std::count_if(v.begin(), v.end(), [](int i) {return i % 3 == 0; });
std::cout << "number divisible by three: " << num_items3 << ‘\n‘;
}
//mismatch查找两个范围第一个不同元素的位置
//返回值是两个迭代器std::make_pair(first1, first2);
{
auto mirror_ends=[](const std::string& in)
{
return std::string(in.begin(),
std::mismatch(in.begin(), in.end(), in.rbegin()).first);
};
std::cout << mirror_ends("abXYZba") << ‘\n‘//ab
<< mirror_ends("abca") << ‘\n‘//a
<< mirror_ends("aba") << ‘\n‘;//aba
}
//find
//find_if
//find_if_not
{
int n1 = 3;
int n2 = 5;
std::vector<int> v{ 0, 1, 2, 3, 4 };
auto result1 = std::find(std::begin(v), std::end(v), n1);
auto result2 = std::find(std::begin(v), std::end(v), n2);
if (result1 != std::end(v)) {
std::cout << "v contains: " << n1 << ‘\n‘;
}
else {
std::cout << "v does not contain: " << n1 << ‘\n‘;
}
if (result2 != std::end(v)) {
std::cout << "v contains: " << n2 << ‘\n‘;
}
else {
std::cout << "v does not contain: " << n2 << ‘\n‘;
}
}
//find_end查找一定范围内最后出现的元素序列
//下列代码用 find_end() 搜索二个不同的数列
{
std::vector<int> v{ 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 };
std::vector<int>::iterator result;
std::vector<int> t1{ 1, 2, 3 };
result = std::find_end(v.begin(), v.end(), t1.begin(), t1.end());
if (result == v.end()) {
std::cout << "subsequence not found\n";
}
else {
std::cout << "last subsequence is at: "
<< std::distance(v.begin(), result) << "\n";
}
std::vector<int> t2{ 4, 5, 6 };
result = std::find_end(v.begin(), v.end(), t2.begin(), t2.end());
if (result == v.end()) {
std::cout << "subsequence not found\n";
}
else {
std::cout << "last subsequence is at: "
<< std::distance(v.begin(), result) << "\n";
}
}
//find_first_of查找元素集合中的任意元素
{
std::vector<int> v{ 0, 2, 3, 25, 5 };
std::vector<int> t{ 3, 19, 10, 2 };
auto result = std::find_first_of(v.begin(), v.end(), t.begin(), t.end());
if (result == v.end()) {
std::cout << "no elements of v were equal to 3, 19, 10 or 2\n";
}
else {
std::cout << "found a match at "
<< std::distance(v.begin(), result) << "\n";
}
}
//adjacent_find查找彼此相邻的两个相同（或其它的关系）的元素
{
std::vector<int> v1{ 0, 1, 2, 3, 40, 40, 41, 41, 5 };
auto i1 = std::adjacent_find(v1.begin(), v1.end());
if (i1 == v1.end()) {
std::cout << "no matching adjacent elements\n";
}
else {
std::cout << "the first adjacent pair of equal elements at: "
<< std::distance(v1.begin(), i1) << ‘\n‘;
}
auto i2 = std::adjacent_find(v1.begin(), v1.end(), std::greater<int>());
if (i2 == v1.end()) {
std::cout << "The entire vector is sorted in ascending order\n";
}
else {
std::cout << "The last element in the non-decreasing subsequence is at: "
<< std::distance(v1.begin(), i2) << ‘\n‘;
}
/*
The first adjacent pair of equal elements at : 4
The last element in the non - decreasing subsequence is at : 7
*/
}
//search查找一个元素区间
{
std::string str = "why waste time learning, when ignorance is instantaneous?";
// str.find() 也能使用
std::cout << std::boolalpha << in_quote(str, "learning") << ‘\n‘
<< in_quote(str, "lemming") << ‘\n‘;
std::vector<char> vec(str.begin(), str.end());
std::cout << std::boolalpha << in_quote(vec, "learning") << ‘\n‘
<< in_quote(vec, "lemming") << ‘\n‘;
}
//search_n
{
const char sequence[] = "1001010100010101001010101";
std::cout << std::boolalpha;
std::cout << "Has 4 consecutive zeros: "
<< consecutive_values(sequence, 4, ‘0‘) << ‘\n‘;
std::cout << "Has 3 consecutive zeros: "
<< consecutive_values(sequence, 3, ‘0‘) << ‘\n‘;
}
}
//写容器/修改容器算法
{
//copy
//copy_if
{
std::vector<int> from_vector(10);
std::iota(from_vector.begin(), from_vector.end(), 0);
std::vector<int> to_vector;
std::copy(from_vector.begin(), from_vector.end(),
std::back_inserter(to_vector));
// 或可选地，
// std::vector<int> to_vector(from_vector.size());
// std::copy(from_vector.begin(), from_vector.end(), to_vector.begin());
// 任一方式都等价于
// std::vector<int> to_vector = from_vector;
std::cout << "to_vector contains: ";
std::copy(to_vector.begin(), to_vector.end(),
std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
}
//copy_n复制一定数目的元素到新的位置
{
std::string in = "1234567890";
std::string out;
std::copy_n(in.begin(), 4, std::back_inserter(out));
std::cout << out << ‘\n‘;
}
//copy_backward按从后往前的顺序复制一个范围内的元素
//要求BidirectionalIterator
{
std::vector<int> from_vector;
for (int i = 0; i < 10; i++) {
from_vector.push_back(i);
}
std::vector<int> to_vector(15);
std::copy_backward(from_vector.begin(), from_vector.end(), to_vector.end());
std::cout << "to_vector contains: ";
for (auto i : to_vector) {
std::cout << i << " ";//0 0 0 0 0 0 1 2 3 4 5 6 7 8 9
}
}
//move
{
auto f=[](int n)
{
std::this_thread::sleep_for(std::chrono::seconds(n));
std::cout << "thread " << n << " ended" << ‘\n‘;
};
std::vector<std::thread> v;
v.emplace_back(f, 1);
v.emplace_back(f, 2);
v.emplace_back(f, 3);
std::list<std::thread> l;
// copy() 无法编译，因为 std::thread 不可复制
std::move(v.begin(), v.end(), std::back_inserter(l));
for (auto& t : l) t.join();
}
//move_backward
{
std::vector<std::string> src{ "foo", "bar", "baz" };
std::vector<std::string> dest(src.size());
std::cout << "src: ";
for (const auto &s : src)
std::cout << s << ‘ ‘;
std::cout << "\ndest: ";
for (const auto &s : dest)
std::cout << s << ‘ ‘;
std::cout << ‘\n‘;
std::move_backward(src.begin(), src.end(), dest.end());
std::cout << "src: ";
for (const auto &s : src)
std::cout << s << ‘ ‘;
std::cout << "\ndest: ";
for (const auto &s : dest)
std::cout << s << ‘ ‘;
std::cout << ‘\n‘;
}
//fill
{
std::vector<int> v{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
std::fill(v.begin(), v.end(), -1);
for (auto elem : v) {
std::cout << elem << " ";
}
std::cout << "\n";
}
//fill_n基本同上
//transform将一个函数应用于某一范围的元素
//和for_each不同的是，它需要指定输出迭代器，且支持2个操作数
{
std::string s("hello");
std::transform(s.begin(), s.end(), s.begin(),
[](unsigned char c) -> unsigned char { return std::toupper(c); });//#include <cctype>
std::vector<std::size_t> ordinals;
std::transform(s.begin(), s.end(), std::back_inserter(ordinals),
[](unsigned char c) -> std::size_t { return c; });
std::cout << s << ‘:‘;
for (auto ord : ordinals) {
std::cout << ‘ ‘ << ord;
}
}
//generate
{
std::vector<int> v(5);
std::generate(v.begin(), v.end(), [n = 0]() mutable { return n++; });
std::cout << "v: ";
for (auto iv : v) {
std::cout << iv << " ";
}
std::cout << "\n";
}
//generate_n几乎同上
//remove
//remove_if
{
std::string str1 = "Text with some spaces";
str1.erase(std::remove(str1.begin(), str1.end(), ‘ ‘),
str1.end());
std::cout << str1 << ‘\n‘;
std::string str2 = "Text\n with\tsome \t whitespaces\n\n";
str2.erase(std::remove_if(str2.begin(),
str2.end(),
[](unsigned char x) {return std::isspace(x); }),
str2.end());
std::cout << str2 << ‘\n‘;
}
//remove_copy
//remove_copy_if
{
std::string str = "Text with some spaces";
std::cout << "before: " << str << "\n";
std::cout << "after: ";
std::remove_copy(str.begin(), str.end(),
std::ostream_iterator<char>(std::cout), ‘ ‘);
std::cout << ‘\n‘;
}
//replace
//replace_if
{
std::array<int, 10> s{ 5, 7, 4, 2, 8, 6, 1, 9, 0, 3 };
std::replace(s.begin(), s.end(), 8, 88);
for (int a : s) {
std::cout << a << " ";//5 7 4 2 88 6 1 9 0 3
}
std::cout << ‘\n‘;
std::replace_if(s.begin(), s.end(),
std::bind(std::less<int>(), std::placeholders::_1, 5), 55);
for (int a : s) {
std::cout << a << " ";//5 7 55 55 88 6 55 9 55 55
}
std::cout << ‘\n‘;
}
//replace_copy
//replace_copy_if
{
std::vector<int> v{ 5, 7, 4, 2, 8, 6, 1, 9, 0, 3 };
std::replace_copy_if(v.begin(), v.end(),
std::ostream_iterator<int>(std::cout, " "),
[](int n) {return n > 5; }, 99);
std::cout << ‘\n‘;
}
//swap
//swap_ranges
{
std::vector<int> v = { 1, 2, 3, 4, 5 };
std::list<int> l = { -1, -2, -3, -4, -5 };
std::swap_ranges(v.begin(), v.begin() + 3, l.begin());
for (int n : v)
std::cout << n << ‘ ‘;//-1 -2 -3 4 5
std::cout << ‘\n‘;
for (int n : l)
std::cout << n << ‘ ‘;//1 2 3 -4 -5
std::cout << ‘\n‘;
}
//iter_swap交换给定的迭代器所指向的元素的值。
{
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dist(-10, 10);
std::vector<int> v;
generate_n(back_inserter(v), 20, bind(dist, gen));
std::cout << "Before sort: ";
copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
selection_sort(v.begin(), v.end());
std::cout << "\nAfter sort: ";
copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
}
//reverse
{
std::vector<int> v{ 1,2,3 };
std::reverse(std::begin(v), std::end(v));
for (auto e : v) std::cout << e;
std::cout << ‘\n‘;
int a[] = { 4, 5, 6, 7 };
std::reverse(std::begin(a), std::end(a));
for (auto e : a) std::cout << e;
}
//reverse_copy
{
std::vector<int> v({ 1,2,3 });
for (const auto& value : v) {
std::cout << value << " ";
}
std::cout << ‘\n‘;
std::vector<int> destination(3);
std::reverse_copy(std::begin(v), std::end(v), std::begin(destination));
for (const auto& value : destination) {
std::cout << value << " ";
}
std::cout << ‘\n‘;
}
//rotate将区间内的元素旋转
{
std::vector<int> v{ 2, 4, 2, 0, 5, 10, 7, 3, 7, 1 };
std::cout << "before sort: ";
for (int n : v)
std::cout << n << ‘ ‘;
std::cout << ‘\n‘; //2 4 2 0 5 10 7 3 7 1
// 插入排序
for (auto i = v.begin(); i != v.end(); ++i) {
std::rotate(std::upper_bound(v.begin(), i, *i), i, i + 1);
}
std::cout << "after sort: ";
for (int n : v)
std::cout << n << ‘ ‘;
std::cout << ‘\n‘;//0 1 2 2 3 4 5 7 7 10
// 简单地旋转到左侧
std::rotate(v.begin(), v.begin() + 1, v.end());
std::cout << "simple rotate left : ";
for (int n : v)
std::cout << n << ‘ ‘;
std::cout << ‘\n‘;//1 2 2 3 4 5 7 7 10 0
// 简单地旋转到右侧
std::rotate(v.rbegin(), v.rbegin() + 1, v.rend());
std::cout << "simple rotate right : ";
for (int n : v)
std::cout << n << ‘ ‘;
std::cout << ‘\n‘;//0 1 2 2 3 4 5 7 7 10
}
//rotate_copy
//random_shuffle将范围内的元素随机重新排序
{
std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
std::random_device rd;
std::mt19937 g(rd());
std::shuffle(v.begin(), v.end(), g);
std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << "\n";
}
//sample,C++17
//unique删除区间内连续重复的元素
{
// 移除重复元素（正常使用）
std::vector<int> v{ 1,2,3,1,2,3,3,4,5,4,5,6,7 };
std::sort(v.begin(), v.end()); // 1 1 2 2 3 3 3 4 4 5 5 6 7
auto last = std::unique(v.begin(), v.end());
// v 现在保有 {1 2 3 4 5 6 7 x x x x x x} ，其中 ‘x‘ 为不确定
v.erase(last, v.end());
for (int i : v)
std::cout << i << " ";
std::cout << "\n";
// 移除连续空格
std::string s = "wanna go to space?";
auto end = std::unique(s.begin(), s.end(), [](char l, char r) {
return std::isspace(l) && std::isspace(r) && l == r;
});
// s 现在保有 "wanna go to space?xxxxxxxx" ，其中 ‘x‘ 为不确定
std::cout << std::string(s.begin(), end) << ‘\n‘;
}
//unique_copy
}
//划分操作
{
//is_partitioned判断区间是否被给定的谓词划分
{
std::array<int, 9> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
auto is_even = [](int i) { return i % 2 == 0; };
std::cout.setf(std::ios_base::boolalpha);
std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ‘ ‘;
std::partition(v.begin(), v.end(), is_even);
std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ‘ ‘;
std::reverse(v.begin(), v.end());
std::cout << std::is_partitioned(v.begin(), v.end(), is_even);
//false true false
}
//partition把一个区间的元素分为两组
{
std::vector<int> v = { 0,1,2,3,4,5,6,7,8,9 };
std::cout << "Original vector:\n ";
for (int elem : v) std::cout << elem << ‘ ‘;
auto it = std::partition(v.begin(), v.end(), [](int i) {return i % 2 == 0; });
std::cout << "\nPartitioned vector:\n ";
std::copy(std::begin(v), it, std::ostream_iterator<int>(std::cout, " "));
std::cout << " * ";
std::copy(it, std::end(v), std::ostream_iterator<int>(std::cout, " "));
std::forward_list<int> fl = { 1, 30, -4, 3, 5, -4, 1, 6, -8, 2, -5, 64, 1, 92 };
std::cout << "\nUnsorted list:\n ";
for (int n : fl) std::cout << n << ‘ ‘;
std::cout << ‘\n‘;
quicksort(std::begin(fl), std::end(fl));
std::cout << "Sorted using quicksort:\n ";
for (int fi : fl) std::cout << fi << ‘ ‘;
std::cout << ‘\n‘;
}
//partition_copy
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int true_arr[5] = { 0 };
int false_arr[5] = { 0 };
std::partition_copy(std::begin(arr), std::end(arr), std::begin(true_arr), std::begin(false_arr),
[](int i) {return i > 5; });
std::cout << "true_arr: ";
for (auto it = std::begin(true_arr); it != std::end(true_arr); ++it) {
std::cout << *it << ‘ ‘;
}
std::cout << ‘\n‘;
std::cout << "false_arr: ";
for (auto it = std::begin(false_arr); it != std::end(false_arr); ++it) {
std::cout << *it << ‘ ‘;
}
std::cout << ‘\n‘;
}
//stable_partition将元素分为两组，同时保留其相对顺序
{
std::vector<int> v{ 0, 0, 3, 0, 2, 4, 5, 0, 7 };
std::stable_partition(v.begin(), v.end(), [](int n) {return n>0; });
for (int n : v) {
std::cout << n << ‘ ‘;
}
std::cout << ‘\n‘;
}
//partition_point
{
std::array<int, 9> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
auto is_even = [](int i) { return i % 2 == 0; };
std::partition(v.begin(), v.end(), is_even);
auto p = std::partition_point(v.begin(), v.end(), is_even);
std::cout << "Before partition:\n ";
std::copy(v.begin(), p, std::ostream_iterator<int>(std::cout, " "));
std::cout << "\nAfter partition:\n ";
std::copy(p, v.end(), std::ostream_iterator<int>(std::cout, " "));
}
}
//排序操作
{
//is_sorted
/*
template<class ForwardIt, class Compare>
bool is_sorted(ForwardIt first, ForwardIt last, Compare comp)
{
return std::is_sorted_until(first, last, comp) == last;
}
*/
{
int digits[] = { 3, 1, 4, 1, 5 };
for (auto i : digits) std::cout << i << ‘ ‘;
std::cout << ": is_sorted: " << std::boolalpha
<< std::is_sorted(std::begin(digits), std::end(digits)) << ‘\n‘;
std::sort(std::begin(digits), std::end(digits));
for (auto i : digits) std::cout << i << ‘ ‘;
std::cout << ": is_sorted: "
<< std::is_sorted(std::begin(digits), std::end(digits)) << ‘\n‘;
}
//is_sorted_until找出最大的已排序子范围
{
std::random_device rd;
std::mt19937 g(rd());
const int N = 6;
int nums[N] = { 3, 1, 4, 1, 5, 9 };
const int min_sorted_size = 4;
int sorted_size = 0;
do {
std::shuffle(nums, nums + N, g);
int *sorted_end = std::is_sorted_until(nums, nums + N);
sorted_size = std::distance(nums, sorted_end);
for (auto i : nums) std::cout << i << ‘ ‘;
std::cout << " : " << sorted_size << " initial sorted elements\n";
} while (sorted_size < min_sorted_size);
}
//sort
{
std::array<int, 10> s = { 5, 7, 4, 2, 8, 6, 1, 9, 0, 3 };
// 用默认的 operator< 排序
std::sort(s.begin(), s.end());
for (auto a : s) {
std::cout << a << " ";
}
std::cout << ‘\n‘;
// 用标准库比较函数对象排序
std::sort(s.begin(), s.end(), std::greater<int>());
for (auto a : s) {
std::cout << a << " ";
}
std::cout << ‘\n‘;
// 用自定义函数对象排序
struct {
bool operator()(int a, int b) const
{
return a < b;
}
} customLess;
std::sort(s.begin(), s.end(), customLess);
for (auto a : s) {
std::cout << a << " ";
}
std::cout << ‘\n‘;
// 用 lambda 表达式排序
std::sort(s.begin(), s.end(), [](int a, int b) {
return b < a;
});
for (auto a : s) {
std::cout << a << " ";
}
std::cout << ‘\n‘;
}
//partial_sort
{
std::array<int, 10> s{ 5, 7, 4, 2, 8, 6, 1, 9, 0, 3 };
std::partial_sort(s.begin(), s.begin() + 3, s.end());
for (int a : s) {
std::cout << a << " ";
}
}
//partial_sort_copy对区间内的元素进行复制并部分排序
{
std::vector<int> v0{ 4, 2, 5, 1, 3 };
std::vector<int> v1{ 10, 11, 12 };
std::vector<int> v2{ 10, 11, 12, 13, 14, 15, 16 };
std::vector<int>::iterator it;
it = std::partial_sort_copy(v0.begin(), v0.end(), v1.begin(), v1.end());
std::cout << "Writing to the smaller vector in ascending order gives: ";
for (int a : v1) {
std::cout << a << " ";// 1 2 3
}
std::cout << ‘\n‘;
if (it == v1.end())
std::cout << "The return value is the end iterator\n";
it = std::partial_sort_copy(v0.begin(), v0.end(), v2.begin(), v2.end(),
std::greater<int>());
std::cout << "Writing to the larger vector in descending order gives: ";
for (int a : v2) {
std::cout << a << " ";//5 4 3 2 1 15 16
}
std::cout << ‘\n‘ << "The return value is the iterator to " << *it << ‘\n‘;//15
}
//stable_sort
{
struct Employee {
Employee(int age, std::string name) : age(age), name(name) { }
int age;
std::string name; // 不参与比较
};
std::vector<Employee> v = {
Employee(108, "Zaphod"),
Employee(32, "Arthur"),
Employee(108, "Ford"),
};
std::stable_sort(v.begin(), v.end(), [](const Employee &lhs, const Employee &rhs) {
return lhs.age < rhs.age; });
for (const Employee &e : v) {
std::cout << e.age << ", " << e.name << ‘\n‘;
}
}
//nth_element将给定的区间部分排序，确保区间被给定的元素划分
/*
nth_element 是部分排序算法，它重排 [first, last) 中元素，使得：
nth 所指向的元素被更改为假如 {tt|[first, last)}} 已排序则该位置会出现的元素。
这个新的 nth 元素前的所有元素小于或等于新的 nth 元素后的所有元素。
*/
{
std::vector<int> v{ 5, 6, 4, 3, 2, 6, 7, 9, 3 };
std::nth_element(v.begin(), v.begin() + v.size() / 2, v.end());
std::cout << "The median is " << v[v.size() / 2] << ‘\n‘;
std::nth_element(v.begin(), v.begin() + 1, v.end(), std::greater<int>());
std::cout << "The second largest element is " << v[1] << ‘\n‘;
//
//The median is 5
//The second largest element is 7
}
}
//二分搜索,针对已排序序列
{
//lower_bound
//upper_bound
{
std::vector<int> data = { 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6 };
//第一个不小于4的iter
auto lower = std::lower_bound(data.begin(), data.end(), 4);
//第一个大于4的iter
auto upper = std::upper_bound(data.begin(), data.end(), 4);
std::copy(lower, upper, std::ostream_iterator<int>(std::cout, " "));//444
std::cout << ‘\n‘;
// 经典二分搜索，仅若存在才返回值
data = { 1, 2, 4, 6, 9, 10 };
auto it = binary_find(data.cbegin(), data.cend(), 4); // 选择 ‘5‘ 的 < 将返回 end()
if (it != data.cend())
//4 found at index 2
std::cout << *it << " found at index " << std::distance(data.cbegin(), it);
}
//binary_search
{
std::vector<int> haystack{ 1, 3, 4, 5, 9 };
std::vector<int> needles{ 1, 2, 3 };
for (auto needle : needles) {
std::cout << "Searching for " << needle << ‘\n‘;
if (std::binary_search(haystack.begin(), haystack.end(), needle)) {
std::cout << "Found " << needle << ‘\n‘;
}
else {
std::cout << "no dice!\n";
}
}
}
//equal_range
{
struct S
{
int number;
char name;
// 注意：此比较运算符忽略 name
bool operator< (const S& s) const { return number < s.number; }
};
std::vector<S> vec = { { 1,‘A‘ },{ 2,‘B‘ },{ 2,‘C‘ },{ 2,‘D‘ },{ 4,‘G‘ },{ 3,‘F‘ } };
S value = { 2, ‘?‘ };
auto p = std::equal_range(vec.begin(), vec.end(), value);
for (auto i = p.first; i != p.second; ++i)
std::cout << i->name << ‘ ‘;
// 异相比较:
struct Comp
{
bool operator() (const S& s, int i) const { return s.number < i; }
bool operator() (int i, const S& s) const { return i < s.number; }
};
auto p2 = std::equal_range(vec.begin(), vec.end(), 2, Comp{});
for (auto i = p2.first; i != p2.second; ++i)
std::cout << i->name << ‘ ‘;
//B C D B C D
}
}
//集合操作
{
//merge
{
std::random_device rd;
std::mt19937 mt(rd());
std::uniform_int_distribution<> dis(0, 9);
std::vector<int> v1(10), v2(10);
std::generate(v1.begin(), v1.end(), std::bind(dis, std::ref(mt)));
std::generate(v2.begin(), v2.end(), std::bind(dis, std::ref(mt)));
// 排序
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
// 输出 v1
std::cout << "v1 : ";
std::copy(v1.begin(), v1.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
// 输出 v2
std::cout << "v2 : ";
std::copy(v2.begin(), v2.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
// 归并
std::vector<int> dst;
std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(dst));
// 输出
std::cout << "dst: ";
std::copy(dst.begin(), dst.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
}
//inplace_merge 就地合并两个有序的区间,注意是有序
//有点复杂，需要再看一遍，此函数试图分配临时缓冲区。若分配失败，则选择较低效的算法。
//交换值即可，为什么参考上说要分配缓冲区？
{
std::vector<int> v{ 8, 2, -2, 0, 11, 11, 1, 7, 3 };
merge_sort(v.begin(), v.end());
for (auto n : v) {
std::cout << n << ‘ ‘;
}
std::cout << ‘\n‘;
}
//includes如果一个集合是另外一个集合的子集则返回true
{
std::vector<char> v1{ ‘a‘, ‘b‘, ‘c‘, ‘f‘, ‘h‘, ‘x‘ };
std::vector<char> v2{ ‘a‘, ‘b‘, ‘c‘ };
std::vector<char> v3{ ‘a‘, ‘c‘ };
std::vector<char> v4{ ‘g‘ };
std::vector<char> v5{ ‘a‘, ‘c‘, ‘g‘ };
for (auto i : v1) std::cout << i << ‘ ‘;
std::cout << "\nincludes:\n" << std::boolalpha;
for (auto i : v2) std::cout << i << ‘ ‘;
std::cout << ": " << std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) << ‘\n‘;
for (auto i : v3) std::cout << i << ‘ ‘;
std::cout << ": " << std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()) << ‘\n‘;
for (auto i : v4) std::cout << i << ‘ ‘;
std::cout << ": " << std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()) << ‘\n‘;
for (auto i : v5) std::cout << i << ‘ ‘;
std::cout << ": " << std::includes(v1.begin(), v1.end(), v5.begin(), v5.end()) << ‘\n‘;
auto cmp_nocase = [](char a, char b) {
return std::tolower(a) < std::tolower(b);
};
std::vector<char> v6{ ‘A‘, ‘B‘, ‘C‘ };
for (auto i : v6) std::cout << i << ‘ ‘;
std::cout << ": (case-insensitive) "
<< std::includes(v1.begin(), v1.end(), v6.begin(), v6.end(), cmp_nocase)
<< ‘\n‘;
}
//set_difference计算两个集合的差集
{
std::vector<int> v1{ 1, 2, 5, 5, 5, 9 };
std::vector<int> v2{ 2, 5, 7 };
std::vector<int> diff;
std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(),
std::inserter(diff, diff.begin()));
for (auto i : v1) std::cout << i << ‘ ‘;
std::cout << "minus ";
for (auto i : v2) std::cout << i << ‘ ‘;
std::cout << "is: ";
for (auto i : diff) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
}
//set_intersection计算两个集合的交集
{
std::vector<int> v1{ 1,2,3,4,5,6,7,8 };
std::vector<int> v2{ 5, 7, 9,10 };
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
std::vector<int> v_intersection;
std::set_intersection(v1.begin(), v1.end(),
v2.begin(), v2.end(),
std::back_inserter(v_intersection));
for (int n : v_intersection)
std::cout << n << ‘ ‘;
}
//set_symmetric_difference计算两个集合的对称差
{
std::vector<int> v1{ 1,2,3,4,5,6,7,8 };
std::vector<int> v2{ 5, 7, 9,10 };
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
std::vector<int> v_symDifference;
std::set_symmetric_difference(
v1.begin(), v1.end(),
v2.begin(), v2.end(),
std::back_inserter(v_symDifference));
for (int n : v_symDifference)
std::cout << n << ‘ ‘;//1 2 3 4 6 8 9 10
}
//set_union计算两个集合的并集
{
std::vector<int> v1 = { 1, 2, 3, 4, 5 };
std::vector<int> v2 = { 3, 4, 5, 6, 7 };
std::vector<int> dest1;
std::set_union(v1.begin(), v1.end(),
v2.begin(), v2.end(),
std::back_inserter(dest1));
for (const auto &i : dest1) {
std::cout << i << ‘ ‘;
}
std::cout << ‘\n‘;
}
}
//堆操作
{
//is_heap检查给定的区间是否为一个堆
{
std::vector<int> v{ 3, 1, 4, 1, 5, 9 };
std::cout << "initially, v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
if (!std::is_heap(v.begin(), v.end())) {
std::cout << "making heap...\n";
std::make_heap(v.begin(), v.end());//建堆。
}
std::cout << "after make_heap, v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
}
//is_heap_until查找区间中为堆的最大子区间
{
std::vector<int> v{ 3, 1, 4, 1, 5, 9 };
std::make_heap(v.begin(), v.end());
// 很可能扰乱堆
v.push_back(2);
v.push_back(6);
auto heap_end = std::is_heap_until(v.begin(), v.end());
std::cout << "all of v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
std::cout << "only heap: ";
for (auto i = v.begin(); i != heap_end; ++i) std::cout << *i << ‘ ‘;
std::cout << ‘\n‘;
//all of v : 9 5 4 1 1 3 2 6
//only heap : 9 5 4 1 1 3 2
}
//make_heap，这个算法很有用，比如leetcode 767,我们需要每次取出最大的两个数，就需要不断地建堆和pop堆
{
std::vector<int> v{ 3, 1, 4, 1, 5, 9 };
std::cout << "initially, v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
std::make_heap(v.begin(), v.end());
std::cout << "after make_heap, v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
std::pop_heap(v.begin(), v.end());
auto largest = v.back();
v.pop_back();
std::cout << "largest element: " << largest << ‘\n‘;
std::cout << "after removing the largest element, v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
}
//push_heap
{
std::vector<int> v{ 3, 1, 4, 1, 5, 9 };
std::make_heap(v.begin(), v.end());
std::cout << "v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
v.push_back(6);
std::cout << "before push_heap: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
std::push_heap(v.begin(), v.end());
std::cout << "after push_heap: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
}
//pop_heap
{
std::vector<int> v{ 3, 1, 4, 1, 5, 9 };
std::make_heap(v.begin(), v.end());
std::cout << "v: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
std::pop_heap(v.begin(), v.end()); // 移动最大元素到结尾
std::cout << "after pop_heap: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
int largest = v.back();
v.pop_back(); // 实际移出最大元素
std::cout << "largest element: " << largest << ‘\n‘;
std::cout << "heap without largest: ";
for (auto i : v) std::cout << i << ‘ ‘;
std::cout << ‘\n‘;
}
//sort_heap
{
std::vector<int> v = { 3, 1, 4, 1, 5, 9 };
std::make_heap(v.begin(), v.end());
std::cout << "heap:\t";
for (const auto &i : v) {
std::cout << i << ‘ ‘;
}
std::sort_heap(v.begin(), v.end());
std::cout << "\nsorted:\t";
for (const auto &i : v) {
std::cout << i << ‘ ‘;
}
std::cout << ‘\n‘;
}
}
//最值操作
{
//max返回两个元素中的较大者
{
std::cout << "larger of 1 and 9999: " << std::max(1, 9999) << ‘\n‘
<< "larger of ‘a‘, and ‘b‘: " << std::max(‘a‘, ‘b‘) << ‘\n‘
<< "longest of \"foo\", \"bar\", and \"hello\": " <<
std::max({ "foo", "bar", "hello" },
[](const std::string& s1, const std::string& s2) {
return s1.size() < s2.size();
}) << ‘\n‘;
}
//max_element返回区间内的最大元素
{
std::vector<int> v{ 3, 1, -14, 1, 5, 9 };
std::vector<int>::iterator result;
result = std::max_element(v.begin(), v.end());
std::cout << "max element at: " << std::distance(v.begin(), result) << ‘\n‘;
auto abs_compare=[](int a, int b)
{
return (std::abs(a) < std::abs(b));
};
result = std::max_element(v.begin(), v.end(), abs_compare);
std::cout << "max element (absolute) at: " << std::distance(v.begin(), result);
}
//min
//min_element
//minmax
{
std::vector<int> v{ 3, 1, 4, 1, 5, 9, 2, 6 };
std::srand(std::time(0));
std::pair<int, int> bounds = std::minmax(std::rand() % v.size(),
std::rand() % v.size());
std::cout << "v[" << bounds.first << "," << bounds.second << "]: ";
for (int i = bounds.first; i < bounds.second; ++i) {
std::cout << v[i] << ‘ ‘;
}
std::cout << ‘\n‘;
}
//minmax_element
{
std::vector<int> v = { 3, 9, 1, 4, 2, 5, 9 };
auto result = std::minmax_element(v.begin(), v.end());
std::cout << "min element at: " << (result.first - v.begin()) << ‘\n‘;
std::cout << "max element at: " << (result.second - v.begin()) << ‘\n‘;
}
//clamp
}
//比较操作
{
//equal
{
auto test=[](const std::string& s)
{
if (std::equal(s.begin(), s.begin() + s.size() / 2, s.rbegin())) {
std::cout << "\"" << s << "\" is a palindrome\n";
}
else {
std::cout << "\"" << s << "\" is not a palindrome\n";
}
};
test("radar");
test("hello");
}
//lexicographic_compare如果按字典顺序一个区间小于另一个区间，返回true
{
std::vector<char> v1{ ‘a‘, ‘b‘, ‘c‘, ‘d‘ };
std::vector<char> v2{ ‘a‘, ‘b‘, ‘c‘, ‘d‘ };
std::mt19937 g{ std::random_device{}() };
while (!std::lexicographical_compare(v1.begin(), v1.end(),
v2.begin(), v2.end())) {
for (auto c : v1) std::cout << c << ‘ ‘;
std::cout << ">= ";
for (auto c : v2) std::cout << c << ‘ ‘;
std::cout << ‘\n‘;
std::shuffle(v1.begin(), v1.end(), g);
std::shuffle(v2.begin(), v2.end(), g);
}
for (auto c : v1) std::cout << c << ‘ ‘;
std::cout << "< ";
for (auto c : v2) std::cout << c << ‘ ‘;
std::cout << ‘\n‘;
}
//compare_3way
//lexicographic_compare_3way
}
//排列操作
{
//is_permutation
{
std::vector<int> v1{ 1,2,3,4,5 };
std::vector<int> v2{ 3,5,4,1,2 };
std::cout << "3,5,4,1,2 is a permutation of 1,2,3,4,5? "
<< std::boolalpha
<< std::is_permutation(v1.begin(), v1.end(), v2.begin()) << ‘\n‘;
std::vector<int> v3{ 3,5,4,1,1 };
std::cout << "3,5,4,1,1 is a permutation of 1,2,3,4,5? "
<< std::boolalpha
<< std::is_permutation(v1.begin(), v1.end(), v3.begin()) << ‘\n‘;
}
//next_permutation 下列代码打印字符串 "aba" 的全部三种排列
{
std::string s = "aba";
std::sort(s.begin(), s.end());
do {
std::cout << s << ‘\n‘;
} while (std::next_permutation(s.begin(), s.end()));
/*
输出：aab
aba
baa
*/
}
//prev_permutation
{
std::string s = "abc";
std::sort(s.begin(), s.end(), std::greater<char>());
do {
std::cout << s << ‘ ‘;
} while (std::prev_permutation(s.begin(), s.end()));
std::cout << ‘\n‘;
}
}
//数值运算
{
//iota用从起始值开始连续递增的值填充区间
{
std::list<int> l(10);
std::iota(l.begin(), l.end(), -4);
std::vector<std::list<int>::iterator> v(l.size());
std::iota(v.begin(), v.end(), l.begin());
std::shuffle(v.begin(), v.end(), std::mt19937{ std::random_device{}() });
std::cout << "Contents of the list: ";
for (auto n : l) std::cout << n << ‘ ‘;
std::cout << ‘\n‘;
std::cout << "Contents of the list, shuffled: ";
for (auto i : v) std::cout << *i << ‘ ‘;
std::cout << ‘\n‘;
/*
Contents of the list: -4 -3 -2 -1 0 1 2 3 4 5
Contents of the list, shuffled: 0 -1 3 4 -4 1 -2 -3 2 5
*/
}
//accumulate
//inner_product内积
{
std::vector<int> a{ 0, 1, 2, 3, 4 };
std::vector<int> b{ 5, 4, 2, 3, 1 };
int r1 = std::inner_product(a.begin(), a.end(), b.begin(), 0);
std::cout << "Inner product of a and b: " << r1 << ‘\n‘;//4+4+9+4=21
//value = op1(value, op2(*first1, *first2));
int r2 = std::inner_product(a.begin(), a.end(), b.begin(), 0,
std::plus<>(), std::equal_to<>());
std::cout << "Number of pairwise matches between a and b: " << r2 << ‘\n‘;
}
//adjacent_difference计算区间内相邻元素之间的差
{
std::vector<int> v{ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
std::adjacent_difference(v.begin(), v.end(), v.begin());
for (auto n : v) {
std::cout << n << ‘ ‘;
}
std::cout << ‘\n‘;
// 斐波那契
// 注意，列表中下一项是当前迭代的结果
v = std::vector<int>(10);
v[0] = 1;
std::adjacent_difference(v.begin(), v.end() - 1, v.begin() + 1, std::plus<int>());
for (auto n : v) {
std::cout << n << ‘ ‘;
}
std::cout << ‘\n‘;
}
//partial_sum
{
std::vector<int> v = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }; // 或 std::vector<int>v(10, 2);
std::cout << "The first 10 even numbers are: ";
std::partial_sum(v.begin(), v.end(),
std::ostream_iterator<int>(std::cout, " "));
std::cout << ‘\n‘;
std::partial_sum(v.begin(), v.end(), v.begin(), std::multiplies<int>());
std::cout << "The first 10 powers of 2 are: ";
for (auto n : v) {
std::cout << n << " ";
}
std::cout << ‘\n‘;
}
//reduce类似于accumulate
{
std::vector<double> v(10‘000‘007, 0.5);
{
auto t1 = std::chrono::high_resolution_clock::now();
double result = std::accumulate(v.begin(), v.end(), 0.0);
auto t2 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> ms = t2 - t1;
std::cout << std::fixed << "std::accumulate result " << result
<< " took " << ms.count() << " ms\n";
}
//VS尚不支持
//{
// auto t1 = std::chrono::high_resolution_clock::now();
// double result = std::reduce(std::execution::par, v.begin(), v.end());
// auto t2 = std::chrono::high_resolution_clock::now();
// std::chrono::duration<double, std::milli> ms = t2 - t1;
// std::cout << "std::reduce result "
// << result << " took " << ms.count() << " ms\n";
//}
}
//exclusive_scan尚不支持
{
}
//inclusive_scan尚不支持
}
//未初始化内存上的操作
{
//uninitialized_copy将范围内的对象复制到未初始化的内存区域
//本质是调用placementNew
//::new (static_cast<void*>(std::addressof(*current))) Value(*first);
{
std::vector<std::string> v = { "This", "is", "an", "example" };
std::string* p;
std::size_t sz;
std::tie(p, sz) = std::get_temporary_buffer<std::string>(v.size());
sz = std::min(sz, v.size());
std::uninitialized_copy(v.begin(), v.begin() + sz, p);
for (std::string* i = p; i != p + sz; ++i) {
std::cout << *i << ‘ ‘;
i->~basic_string<char>();
}
std::return_temporary_buffer(p);
}
//uninitialized_copy_n
{
std::vector<std::string> v = { "This", "is", "an", "example" };
std::string* p;
std::size_t sz;
std::tie(p, sz) = std::get_temporary_buffer<std::string>(v.size());
sz = std::min(sz, v.size());
std::uninitialized_copy_n(v.begin(), sz, p);
for (std::string* i = p; i != p + sz; ++i) {
std::cout << *i << ‘ ‘;
i->~basic_string<char>();
}
std::return_temporary_buffer(p);
}
//uninitialized_fill复制一个对象到以范围定义的未初始化内存区域
{
std::string* p;
std::size_t sz;
std::tie(p, sz) = std::get_temporary_buffer<std::string>(4);
std::uninitialized_fill(p, p + sz, "Example");
for (std::string* i = p; i != p + sz; ++i) {
std::cout << *i << ‘\n‘;
i->~basic_string<char>();
}
std::return_temporary_buffer(p);
}
//uninitialized_fill_n
//以下均为C++17支持
//uninitialized_move
{
/*可能的实现
template<class InputIt, class ForwardIt>
ForwardIt uninitialized_move(InputIt first, InputIt last, ForwardIt d_first)
{
typedef typename std::iterator_traits<ForwardIt>::value_type Value;
ForwardIt current = d_first;
try {
for (; first != last; ++first, (void) ++current) {
::new (static_cast<void*>(std::addressof(*current))) Value(std::move(*first));
}
return current;
}
catch (...) {
for (; d_first != current; ++d_first) {
d_first->~Value();
}
throw;
}
}
//关键代码是::new (static_cast<void*>(std::addressof(*current))) Value(std::move(*first));
//初始化对象时以右值构造
*/
}
//uninitialized_move_n
//uninitialized_default_construct
//uninitialized_default_construct_n
//uninitialized_value_construct
//uninitialized_vaule_construct_n
//destroy_at
//destroy
//destroy_n
}
//C库
{
//qsort
//无关乎名称， C++ 、 C 及 POSIX 都不要求此函数用快速排序实现或作出任何复杂度和稳定性保证。
{
int a[] = { -2, 99, 0, -743, 2, INT_MIN, 4 };
constexpr std::size_t size = sizeof a / sizeof *a;
std::qsort(a, size, sizeof *a, [](const void* a, const void* b)
{
int arg1 = *static_cast<const int*>(a);
int arg2 = *static_cast<const int*>(b);
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
// 返回 (arg1 > arg2) - (arg1 < arg2); // 可行的缩写
// 返回 arg1 - arg2; // 错误的缩写（若有 INT_MIN 则失败）
});
for (int ai : a)
std::cout << ai << ‘ ‘;
}
//bsearch
{
const int ARR_SIZE = 8;
int arr[ARR_SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8 };
int key1 = 4;
auto compare=[](const void *ap, const void *bp)
{
auto a = static_cast<const int *>(ap);
auto b = static_cast<const int *>(bp);
if (*a < *b)
return -1;
else if (*a > *b)
return 1;
else
return 0;
};
int *p1 = (int *)std::bsearch(&key1, arr, ARR_SIZE, sizeof(arr[0]), compare);
if (p1)
std::cout << "value " << key1 << " found at position " << (p1 - arr) << ‘\n‘;
else
std::cout << "value " << key1 << " not found\n";
int key2 = 9;
int *p2 = (int *)std::bsearch(&key2, arr, ARR_SIZE, sizeof(arr[0]), compare);
if (p2)
std::cout << "value " << key2 << " found at position " << (p2 - arr) << ‘\n‘;
else
std::cout << "value " << key2 << " not found\n";
}
}
{
vector<int> vec_int{ 1,2,2,3,3,3,4,4,4,4,5,6,26,17,8,19,10 };
vector<string> vec_string{ "i","love","you" };
}
return 0;
}
原文地址：https://www.cnblogs.com/lsaejn/p/9733729.html
时间： 2024-11-08 20:30:52