C++基础-----函数，起始函数，结束函数，排序函数等

begin()：获取向量的起始位置迭代器

end()：获取向量的结束位置迭代器

iterator（迭代器）是C++标准库中用于遍历容器元素的一种抽象概念

std::sort是C++标准库中的一个算法函数，用于对一个序列中的元素进行排序

std::find：用于在给定范围内查找特定值的第一个匹配项，find函数接受一个范围 [first, last)，以及要查找的值 value。它返回一个指向第一个匹配项的迭代器，如果没有找到匹配项，则返回 last

std::count：它用于计算在给定范围内某个值出现的次数。这个函数在 头文件中定义

std::count_if：它用于计算满足特定条件的元素在给定范围内出现的次数。

replace（替换）：是一个常用的字符串操作函数，用于在字符串中替换指定的字符或子串

all_of是C++标准库中的一个算法函数，用于判断一个序列中的所有元素是否都满足某个条件

any_of是C++标准库中的一个算法函数，用于判断一个序列中是否存在至少一个元素满足某个条件

none_of是C++标准库中的一个算法函数，用于判断一个序列中的所有元素是否都不满足某个条件。

transform是C++标准库中的一个算法函数，用于对一个序列中的元素进行转换操作

std::min_element是C++标准库中的一个算法函数，用于在一个序列中找到最小元素的位置

std::max_element是C++标准库中的一个算法函数，用于在一个序列中找到最大元素的位置

std::adjacent_find是C++标准库中的一个算法函数，用于在一个序列中查找相邻元素的重复项

std::accumulate是C++标准库中的一个算法函数，用于对一个序列中的元素进行累加操作

#include 
#include 
#include 

int main() {
    std::vector<int> nums {1, 6, 2, 8, 4, 9, 3, 7, 5};
    
    int count = std::count_if(nums.begin(), nums.end(), [](int num) {
        return num > 5;
    });
    
    std::cout << "Count: " << count << std::endl;
    
    return 0;
}

/*
* 算法示例
* STL算法基于迭代器生成的序列
* STL提供了很多算法（例如查找、排序、计数、操作），可以对序列进行操作
* 多数算法要求提供额外参数，例如：排序算法需要提供排序规则，一般使用函数指针、lambda表达式或仿函数（函数对象）
*/

#include 
#include 
#include  // 算法头文件
#include 

void test1()
{
    std::cout << "test1 ======================" << std::endl;

    std::vector<int> v1{1, 2, 3, 4, 5};
    std::vector<int>::iterator loc = std::find(v1.begin(), v1.end(), 8); // 查找3
    if (loc != v1.end())
        std::cout << "找到 3" << std::endl;
    else
        std::cout << "未找到 3" << std::endl;
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 1, 2, 1};
    int counts = std::count(v1.begin(), v1.end(), 1); // 统计1的个数
    std::cout << "1的个数: " << counts << std::endl;
}

// 判断是否是偶数
bool isEven(int x)
{
    return x % 2 == 0;
}
void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8, 9};

    int counts = std::count_if(v1.begin(), v1.end(), isEven); // 使用函数指针统计偶数个数

    counts = std::count_if(v1.begin(), v1.end(), [](int x)
                           { return x % 2 == 0; }); // 使用lambda表达式统计偶数个数
    std::cout << "偶数个数: " << counts << std::endl;

    counts = std::count_if(v1.begin(), v1.end(), [](int x)
                           { return x > 6; }); // 统计大于6的个数
    std::cout << "大于6的个数: " << counts << std::endl;
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 1, 2, 1};
    for (const auto &e : v1)
        std::cout << e << " ";
    
    std::cout << std::endl;

    std::replace(v1.begin(), v1.end(), 1, 100); // 将1替换为100

    for (const auto &e : v1)
        std::cout << e << " ";
    std::cout << std::endl;
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8, 9};
    if (std::all_of(v1.begin(), v1.end(), [](int x) { return x > 5; }) ) // 所有元素都大于5
        std::cout << "所有元素都大于5" << std::endl;
    else
        std::cout << "不是所有元素都大于5" << std::endl;
    
    if (std::any_of(v1.begin(), v1.end(), [](int x) { return x > 5; }) ) // 至少有一个元素大于5
        std::cout << "有元素大于5" << std::endl;
    else
        std::cout << "没有元素大于5" << std::endl;

    if (std::none_of(v1.begin(), v1.end(), [](int x) { return x < 0; }) ) // 没有元素小于0
        std::cout << "没有元素小于0" << std::endl;
    else
        std::cout << "有元素小于0" << std::endl;

}

void test6()
{
    std::cout << "test6 ======================" << std::endl;
    std::string s1 {"hello world"};
    std::cout << s1 << std::endl;
    std::transform(s1.begin(), s1.end(), s1.begin(), ::toupper); // 转换为大写，从s1的begin到end，转换后的结果放到s1的begin
    std::cout << s1 << std::endl;

}
int main()
{
    // test1();
    // test2();
    // test3();
    // test4();
    // test5();
    // test6();

    return 0;
}

/*
* array容器示例
* array大小固定，不可改变
* 在内存中是连续的
* 获取元素的复杂度是常数，与array元素个数无关
* 是对原始数组的封装，也可以获取原始数组的指针
* 如果数组大小固定，尽量使用array，而不是使用C++原生数组，因为array可以使用标准库的算法
*/

#include 
#include  // 使用array容器
#include  
#include  

// 打印数组
void display(const std::array<int,5> &arr)
{
    std::cout << "[ ";
    for (const auto &a: arr)
        std::cout << a << " ";
    std::cout << "]" << std::endl;
}


void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::array<int, 5> arr1 {1, 2, 3, 4, 5};
    std::array<int, 5> arr2;

    display(arr1);
    display(arr2); // 未初始化，值为随机值

    arr2 = {10, 20, 30, 40, 50}; // 可以直接赋值

    display(arr1);
    display(arr2); 

    std::cout << "arr1的大小：" << arr1.size() << std::endl;
    std::cout << "arr2的大小：" << arr2.size() << std::endl;

    arr1[0] = 1000;
    arr1.at(1) = 2000;
    display(arr1);

    std::cout << "arr1的第一个元素：" << arr1.front() << std::endl;
    std::cout << "arr1的最后一个元素：" << arr1.back() << std::endl;
    



}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::array<int, 5> arr1 {1, 2, 3, 4, 5};
    std::array<int, 5> arr2 {10, 20, 30, 40, 50};

    display(arr1);
    display(arr2);

    arr1.fill(0);
    display(arr1);
    display(arr2);

    arr1.swap(arr2);
    display(arr1);
    display(arr2);

    
}

void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::array<int, 5> arr1 {1, 2, 3, 4, 5};
    int *ptr = arr1.data(); // 返回数组的首地址
    std::cout << ptr << std::endl;
    std::cout << *ptr << std::endl;
    *ptr = 1000;
    display(arr1);
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::array<int, 5> arr1 {3,1,4,2,5};
    display(arr1);
    std::sort(arr1.begin(), arr1.end());
    display(arr1);
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    std::array<int, 5> arr1 {3,6,4,2,5};
    std::array<int, 5>::iterator min_val = std::min_element(arr1.begin(), arr1.end());
    auto max_val = std::max_element(arr1.begin(), arr1.end());
    std::cout << "min: " << *min_val << std::endl;
    std::cout << "max: " << *max_val << std::endl;
}

void test6()
{
    std::cout << "test6 ======================" << std::endl;
    std::array<int, 5> arr1 {3,6,2,2,5};
    
    auto adjacent = std::adjacent_find(arr1.begin(), arr1.end()); // 查找相邻的两个相同的元素
    if (adjacent != arr1.end())
        std::cout << "adjacent: " << *adjacent << std::endl;
    else
        std::cout << "没有找到相邻的两个相同的元素" << std::endl;

}

void test7()
{
    std::cout << "test7 ======================" << std::endl;
    std::array<int, 5> arr1 {1,2,3,4,5};
    int sum = std::accumulate(arr1.begin(), arr1.end(), 0); // 求和
    std::cout << "sum: " << sum << std::endl;

}

void test8()
{
    std::cout << "test8 ======================" << std::endl;
    std::array<int, 10> arr1 {1,2,3,4,5,5,5,5,5,5};
    int counts = std::count(arr1.begin(), arr1.end(), 5); // 统计5的个数
    std::cout << "5一共出现了" << counts << "次" << std::endl;
}
int main()
{
    // test1();
    // test2();
    // test3();
    // test4();
    // test5();
    // test6();
    // test7();
    test8();
    return 0;
}