C++笔记 写容器元素的算法

primer C++笔记

写容器元素的算法

#include <iostream>
#include <stdlib.h>
#include <vector>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <random>
#include <functional>
#include <array>
using namespace std;

namespace WriteOnly
{
	/*fill(beg, end, val);
	fill_n(dest, cnt, val);
	generate(beg, end, Gen);
	generate(dest, cnt, Gen);*/
	void test01()
	{
		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";

		//-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
	}

	int f()
	{
		static int i = 1;
		return i++;
	}
	void test02()
	{
		std::vector<int> v(5);
		std::generate(v.begin(), v.end(), f);

		std::cout << "v: ";
		for (auto iv : v) {
			std::cout << iv << " ";
		}
		std::cout << "\n";

		// 以来自 lambda 函数的默认值 0,1,2,3,4 初始化
		// 等价于 std::iota(v.begin(), v.end(), 0);
		std::generate(v.begin(), v.end(), [n = 0]() mutable { return n++; });

		std::cout << "v: ";
		for (auto iv : v) {
			std::cout << iv << " ";
		}
		std::cout << "\n";

		/*v: 1 2 3 4 5
		v : 0 1 2 3 4*/
	}
}

#include <list>
#include <thread>
#include <chrono>
#include <cctype>
#include <string>
namespace InputIt
{
	/*copy(beg, end, dest);
	copy_if(beg, end, dest, unaryPerd);
	copy_n(beg, n, dest);*/
	void test01()
	{
		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';
		
		//to_vector contains: 0 1 2 3 4 5 6 7 8 9
	}

	//move(beg, end, dest);
	void f(int n)
	{
		std::this_thread::sleep_for(std::chrono::seconds(n));
		std::cout << "thread " << n << " ended" << '\n';
	}
	void test02()
	{
		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();
	
		/*thread 1 ended
		thread 2 ended
		thread 3 ended*/
	}

	/*transform(beg, end, dest, unaryOp);
	transform(beg, end, beg2, dest, binaryOp);*/
	void test03()
	{
		std::string s("hello");
		std::transform(s.begin(), s.end(), s.begin(),
			[](unsigned char c) -> unsigned char { return std::toupper(c); });

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

		//HELLO: 72 69 76 76 79
	}

	//replace_copy(beg, end, dest, old_val, new_val);
	//replace_copy_if(beg, end, dest, unaryPred, new_val);
	void test04()
	{
		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';

		//5 99 4 2 99 99 1 99 0 3
	}

	//merge(beg1, end1, beg2, end2, dest);
	//merge(beg1, end1, beg2, end2, dest, comp);
	void test05()
	{
		// 以随机数填充 vector
		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';

		/*v1: 0 1 3 4 4 5 5 8 8 9
		v2 : 0 2 2 3 6 6 8 8 8 9
		dst : 0 0 1 2 2 3 3 4 4 5 5 6 6 8 8 8 8 8 9 9*/
	}

}


namespace ForwardIt
{
	//iter_swap(iter1, iter2);
	//swap_range(beg1, end1, beg2);
	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));
	}
	void test01()
	{
		std::random_device rd;
		std::mt19937 gen(rd());
		std::uniform_int_distribution<> dist(-10, 10);
		std::vector<int> v;
		std::generate_n(back_inserter(v), 20, bind(dist, gen));

		std::cout << "Before sort: ";
		for (auto e : v) std::cout << e << " ";

		selection_sort(v.begin(), v.end());

		std::cout << "\nAfter sort: ";
		for (auto e : v) std::cout << e << " ";
		std::cout << '\n';

		//Before sort : -7 6 2 4 - 1 6 - 9 - 1 2 - 5 10 - 9 - 5 - 3 - 5 - 3 6 6 1 8
		//After sort : -9 - 9 - 7 - 5 - 5 - 5 - 3 - 3 - 1 - 1 1 2 2 4 6 6 6 6 8 10
	}

	//replace(beg, end, old_val, new_val);
	//replace_if(beg, end, unaryPred, new_val);
	void test02()
	{
		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 << " ";
		}
		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 << " ";
		}
		std::cout << '\n';

		//5 7 4 2 88 6 1 9 0 3
		//5 7 55 55 88 6 55 9 55 55
	}

}

namespace BidirIt
{
	//copy_backward(beg, end, dest);
	//move_backward(beg, end, dest);
	void test01()
	{
		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 << " ";
		
		}

		//to_vector contains: 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9
	}

	void test02()
	{
		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';
			
		/*src: foo bar baz
		dest :
		src:
		dest: foo bar baz*/
	}

	//inplace_merge(beg, mid, end);
	//inplace_merge(beg, mid, end, comp);
	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);
		}
	}

	void test03()
	{
		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';

		//-2 0 1 2 3 7 8 11 11
	}
}