【C++之泛型算法】006Fredicate用以检验区间

最新推荐文章于 2024-07-25 23:26:35 发布
最新推荐文章于 2024-07-25 23:26:35 发布
阅读量762 收藏 18
点赞数 24
分类专栏： C++ 文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d710055071/article/details/137656705
版权

文章目录

is_sorted()

std::is_sorted 是 C++ 标准库中的一个泛型算法，用于检查一个序列是否已按升序排序。它接受两个迭代器，分别表示序列的开始和结束，并返回一个布尔值，指示序列是否已排序。

下面是一个使用 std::is_sorted 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量并初始化
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用 is_sorted 检查向量是否已排序
    bool isSorted = std::is_sorted(vec.begin(), vec.end());

    // 输出检查结果
    if (isSorted) {
        std::cout << "The vector is sorted." << std::endl;
    } else {
        std::cout << "The vector is not sorted." << std::endl;
    }

    // 修改向量中的一个元素以使其不再排序
    vec[2] = 0;

    // 再次检查向量是否已排序
    isSorted = std::is_sorted(vec.begin(), vec.end());

    // 输出检查结果
    if (isSorted) {
        std::cout << "The vector is sorted." << std::endl;
    } else {
        std::cout << "The vector is not sorted." << std::endl;
    }

    return 0;
}

在这个例子中，我们首先创建了一个整数向量 vec 并初始化为升序排列。然后，我们使用 std::is_sorted 来检查这个向量是否已排序，由于它是升序排列的，所以输出将是 “The vector is sorted.”。

接下来，我们修改了向量中的一个元素，使其不再按升序排列。再次调用 std::is_sorted 检查向量时，这次它将返回 false，因此输出将是 “The vector is not sorted.”。

std::is_sorted 还有一个带自定义比较函数的版本，允许你提供自己的比较逻辑。这在你需要对非标准类型的序列进行排序检查时非常有用。下面是一个使用自定义比较函数的 std::is_sorted 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数，用于比较两个字符串的长度
bool compare_by_length(const std::string& a, const std::string& b) {
    return a.size() < b.size();
}

int main() {
    // 创建一个字符串向量
    std::vector<std::string> vec = {"apple", "banana", "cherry", "blueberry"};

    // 使用自定义比较函数检查向量是否已排序
    bool isSorted = std::is_sorted(vec.begin(), vec.end(), compare_by_length);

    // 输出检查结果
    if (isSorted) {
        std::cout << "The vector is sorted by length." << std::endl;
    } else {
        std::cout << "The vector is not sorted by length." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个比较函数 compare_by_length，它比较两个字符串的长度。然后，我们将这个函数作为第三个参数传递给 std::is_sorted，以检查向量是否按字符串长度升序排列。

is_sorted_until()

std::is_sorted_until 是 C++ 标准库中的一个泛型算法，它用于查找一个序列中第一个破坏排序顺序的元素。换句话说，它返回指向序列中第一个不满足排序条件的元素的迭代器。如果整个序列都是排序的，则它返回序列的尾迭代器。

这个算法对于确定一个序列的哪部分是有序的，而无需检查整个序列非常有用。

下面是使用 std::is_sorted_until 的一个例子：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量并初始化
    std::vector<int> vec = {1, 2, 3, 5, 4, 6, 7, 8};

    // 使用 is_sorted_until 查找第一个破坏排序顺序的元素
    auto it = std::is_sorted_until(vec.begin(), vec.end());

    // 输出结果
    if (it != vec.end()) {
        std::cout << "The first element that is out of order is: " << *it << std::endl;
    } else {
        std::cout << "The entire sequence is sorted." << std::endl;
    }

    // 输出从开始到破坏排序的元素之前的所有元素
    for (auto elem = vec.begin(); elem != it; ++elem) {
        std::cout << *elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，vec 是一个整数向量，其中第四个元素 5 破坏了升序排序。std::is_sorted_until 返回指向这个元素的迭代器，然后我们输出这个元素以及它之前的所有元素。

std::is_sorted_until 同样有一个接受自定义比较函数的版本，允许你提供自定义的比较逻辑来判定元素是否满足排序条件。以下是一个使用自定义比较函数的 std::is_sorted_until 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数，用于比较两个整数的绝对值
bool compare_absolute_value(int a, int b) {
    return std::abs(a) < std::abs(b);
}

int main() {
    // 创建一个整数向量并初始化
    std::vector<int> vec = {-3, -1, 2, -4, 1, 5, -6};

    // 使用 is_sorted_until 和自定义比较函数查找第一个破坏排序顺序的元素
    auto it = std::is_sorted_until(vec.begin(), vec.end(), compare_absolute_value);

    // 输出结果
    if (it != vec.end()) {
        std::cout << "The first element that is out of order (by absolute value) is: " << *it << std::endl;
    } else {
        std::cout << "The entire sequence is sorted by absolute value." << std::endl;
    }

    // 输出从开始到破坏排序的元素之前的所有元素
    for (auto elem = vec.begin(); elem != it; ++elem) {
        std::cout << *elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们定义了一个比较函数 compare_absolute_value，它比较两个整数的绝对值。然后，我们将这个函数作为 std::is_sorted_until 的第三个参数传递，以便算法使用这个自定义的比较逻辑来检查序列的排序状态。

is_partitioned()

std::is_partitioned 是 C++ 标准库中的一个泛型算法，用于检查一个序列是否根据给定的谓词（predicate）被划分成两部分。换句话说，这个算法检查序列是否可以从一个点开始被划分为两部分，使得在划分点之前的所有元素都满足谓词，而之后的元素都不满足谓词。

以下是 std::is_partitioned 的基本用法示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义谓词函数，检查一个整数是否小于 5
bool is_less_than_five(int n) {
    return n < 5;
}

int main() {
    // 创建一个整数向量
    std::vector<int> vec = {1, 2, 3, 6, 7, 8};

    // 使用 is_partitioned 检查向量是否根据谓词 is_less_than_five 被划分
    bool result = std::is_partitioned(vec.begin(), vec.end(), is_less_than_five);

    // 输出结果
    if (result) {
        std::cout << "The vector is partitioned according to the predicate." << std::endl;
    } else {
        std::cout << "The vector is not partitioned according to the predicate." << std::endl;
    }

    // 更改向量中的一个元素，使其不满足谓词
    vec[2] = 6;

    // 再次检查向量是否根据谓词被划分
    result = std::is_partitioned(vec.begin(), vec.end(), is_less_than_five);

    // 输出结果
    if (result) {
        std::cout << "The vector is partitioned according to the predicate." << std::endl;
    } else {
        std::cout << "The vector is not partitioned according to the predicate." << std::endl;
    }

    return 0;
}

在这个例子中，我们首先定义了一个谓词函数 is_less_than_five，它检查一个整数是否小于 5。然后，我们创建了一个整数向量 vec 并用 std::is_partitioned 检查它是否根据这个谓词被划分。由于 vec 的前三个元素（1, 2, 3）都小于 5，而后面的元素（6, 7, 8）都不小于 5，所以第一次调用 std::is_partitioned 返回 true。

接着，我们更改了 vec 的第三个元素为 6，这样它就不再满足谓词 is_less_than_five。因此，当我们再次调用 std::is_partitioned 时，它返回 false，因为序列现在不能被单一划分点划分为两部分，使得划分点之前的所有元素都满足谓词。

注意，std::is_partitioned 只检查是否存在这样的划分点，而不返回这个划分点的位置。如果你需要找到这个划分点的位置，可以使用 std::partition_point 算法。

partition_point()

std::partition_point 是 C++ 标准库中的一个泛型算法，它用于确定一个序列中满足特定谓词（predicate）的第一个元素的位置。这个算法常用于配合 std::partition 或 std::stable_partition 使用，这些算法会重新排列序列，使得满足谓词的元素出现在不满足谓词的元素之前。std::partition_point 则返回这个分界点的位置。

std::partition_point 的使用场景通常是在你已经对序列进行了划分操作后，想要知道划分点在哪里，而不必重新对整个序列进行划分。

下面是一个使用 std::partition_point 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义谓词函数，检查一个整数是否小于 5
bool is_less_than_five(int n) {
    return n < 5;
}

int main() {
    // 创建一个整数向量
    std::vector<int> vec = {1, 2, 3, 6, 7, 8};

    // 使用 partition 对向量进行划分，使得小于 5 的元素在前
    std::partition(vec.begin(), vec.end(), is_less_than_five);

    // 使用 partition_point 查找划分点的位置
    auto partition_point_it = std::partition_point(vec.begin(), vec.end(), is_less_than_five);

    // 输出划分点的位置
    std::cout << "Partition point: " << std::distance(vec.begin(), partition_point_it) << std::endl;

    // 输出划分点之前的所有元素
    for (auto it = vec.begin(); it != partition_point_it; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先使用 std::partition 对 vec 进行划分，使得所有小于 5 的元素都出现在大于或等于 5 的元素之前。然后，我们使用 std::partition_point 查找划分点的位置，并输出它。最后，我们遍历并输出划分点之前的所有元素。

注意，std::partition 和 std::partition_point 都不会保证划分点之后的元素满足谓词或不满足谓词，它们只保证划分点之前的元素都满足谓词。如果你需要确保划分点之后的元素都不满足谓词，你可以使用 std::stable_partition 代替 std::partition。

is_heap()

std::is_heap 是 C++ 标准库中的一个泛型算法，用于检查给定范围的元素是否形成堆（Heap）。堆是一种特殊的树形数据结构，通常通过数组来实现，其中每个父节点的值都大于或等于（在最大堆中）或小于或等于（在最小堆中）其子节点的值。

std::is_heap 有两个版本：默认版本和自定义比较版本。
默认版本

默认版本的 std::is_heap 接受两个迭代器作为参数，分别表示要检查的序列的开始和结束。它返回一个布尔值，指示该序列是否形成一个有效的最大堆。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量并初始化为最大堆
    std::vector<int> vec = {9, 5, 7, 3, 1};

    // 使用 make_heap 将向量转换为最大堆
    std::make_heap(vec.begin(), vec.end());

    // 检查向量是否是一个有效的最大堆
    bool isMaxHeap = std::is_heap(vec.begin(), vec.end());

    // 输出检查结果
    if (isMaxHeap) {
        std::cout << "The vector is a valid max heap." << std::endl;
    } else {
        std::cout << "The vector is not a valid max heap." << std::endl;
    }

    return 0;
}

在这个例子中，我们首先创建了一个整数向量 vec 并初始化为一个序列。然后，我们使用 std::make_heap 将这个序列转换为一个最大堆。最后，我们使用 std::is_heap 检查转换后的向量是否仍然是一个有效的最大堆，并输出检查结果。
自定义比较版本

自定义比较版本的 std::is_heap 接受三个参数：两个迭代器表示要检查的序列的开始和结束，以及一个比较函数或可调用对象，用于定义堆的顺序。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数，用于定义最小堆的顺序
bool isLess(int a, int b) {
    return a < b;
}

int main() {
    // 创建一个整数向量并初始化为最小堆
    std::vector<int> vec = {1, 3, 5, 7, 9};

    // 使用自定义比较函数检查向量是否是一个有效的最小堆
    bool isMinHeap = std::is_heap(vec.begin(), vec.end(), isLess);

    // 输出检查结果
    if (isMinHeap) {
        std::cout << "The vector is a valid min heap." << std::endl;
    } else {
        std::cout << "The vector is not a valid min heap." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个自定义比较函数 isLess，用于检查一个整数是否小于另一个整数。然后，我们创建了一个整数向量 vec 并初始化为一个最小堆。最后，我们使用 std::is_heap 和自定义比较函数检查这个向量是否仍然是一个有效的最小堆，并输出检查结果。

is_heap_until()

std::is_heap_until 是 C++ 标准库中的一个泛型算法，用于确定给定范围内的元素序列保持堆性质的最后位置。换句话说，它会找到最后一个违反堆性质的元素，并返回指向该元素之后的位置的迭代器。如果整个序列都是有效的堆，那么它将返回范围的末尾迭代器。

std::is_heap_until 有两个版本：默认版本和自定义比较版本。
默认版本

默认版本的 std::is_heap_until 接受两个迭代器作为参数，分别表示要检查的序列的开始和结束。它返回一个迭代器，指向保持堆性质的最后一个元素之后的位置。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量并初始化为最大堆
    std::vector<int> vec = {9, 5, 7, 3, 1, 2, 6};

    // 假设 vec 的前五个元素是有效的最大堆

    // 使用 is_heap_until 查找违反堆性质的第一个元素
    auto it = std::is_heap_until(vec.begin(), vec.end());

    // it 现在指向第一个违反堆性质的元素，即 vec[5]

    // 输出结果
    std::cout << "The sequence is a valid heap until position: " 
              << std::distance(vec.begin(), it) << std::endl;

    return 0;
}

在这个例子中，我们创建了一个包含七个元素的整数向量 vec。假设前五个元素（9, 5, 7, 3, 1）是一个有效的最大堆，但从第六个元素开始，堆性质被破坏了（因为 1 大于 2）。std::is_heap_until 将返回指向第六个元素（即 2）的迭代器，因为这个元素是第一个违反堆性质的元素。
自定义比较版本

自定义比较版本的 std::is_heap_until 接受三个参数：两个迭代器表示要检查的序列的开始和结束，以及一个比较函数或可调用对象，用于定义堆的顺序。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数，用于定义最小堆的顺序
bool isLess(int a, int b) {
    return a < b;
}

int main() {
    // 创建一个整数向量并初始化为最小堆
    std::vector<int> vec = {1, 3, 5, 7, 9, 2, 6};

    // 假设 vec 的前五个元素是有效的最小堆

    // 使用自定义比较函数和 is_heap_until 查找违反堆性质的第一个元素
    auto it = std::is_heap_until(vec.begin(), vec.end(), isLess);

    // it 现在指向第一个违反堆性质的元素，即 vec[5]

    // 输出结果
    std::cout << "The sequence is a valid heap until position: " 
              << std::distance(vec.begin(), it) << std::endl;

    return 0;
}

在这个例子中，我们定义了一个自定义比较函数 isLess，用于检查一个整数是否小于另一个整数。然后，我们创建了一个包含七个元素的整数向量 vec，并假设前五个元素（1, 3, 5, 7, 9）是一个有效的最小堆。从第六个元素开始，堆性质被破坏了（因为 9 小于 2）。使用自定义比较函数和 std::is_heap_until，我们可以找到第一个违反最小堆性质的元素（即 2），并输出其位置。

all_of()

std::all_of 是 C++ 标准库中的一个算法，它用于检查给定范围内的所有元素是否都满足某个条件。该算法接受一个范围（由两个迭代器定义）和一个断言函数或可调用对象，然后应用该断言函数到范围中的每个元素，并检查是否所有元素都使断言函数返回 true。如果所有元素都满足条件，则 std::all_of 返回 true，否则返回 false。
默认版本

默认版本的 std::all_of 使用给定的断言函数或 lambda 表达式来检查范围内的所有元素。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用 std::all_of 检查所有元素是否都大于 0
    bool allPositive = std::all_of(numbers.begin(), numbers.end(), [](int n) {
        return n > 0;
    });

    // 输出结果
    if (allPositive) {
        std::cout << "All numbers are positive." << std::endl;
    } else {
        std::cout << "There are negative numbers." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个 lambda 表达式来检查一个整数是否大于 0。std::all_of 应用这个 lambda 表达式到 numbers 向量中的每个元素，并因为所有元素都大于 0，所以返回 true。
自定义断言版本

你也可以提供一个自定义的断言函数作为 std::all_of 的第三个参数。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义断言函数，检查一个整数是否是偶数
bool isEven(int n) {
    return n % 2 == 0;
}

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {2, 4, 6, 8, 10};

    // 使用自定义断言函数检查所有元素是否都是偶数
    bool allEven = std::all_of(numbers.begin(), numbers.end(), isEven);

    // 输出结果
    if (allEven) {
        std::cout << "All numbers are even." << std::endl;
    } else {
        std::cout << "There are odd numbers." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个名为 isEven 的函数，它检查一个整数是否是偶数。然后，我们将这个函数作为 std::all_of 的第三个参数，以检查 numbers 向量中的所有元素是否都是偶数。因为所有元素都是偶数，所以 std::all_of 返回 true。

这两种版本（默认和自定义断言）的用法都非常灵活，可以根据需要选择使用 lambda 表达式还是自定义函数来定义检查条件

any_of()

std::any_of 是 C++ 标准库中的一个算法，用于检查给定范围内的元素是否满足某个条件。这个算法会应用一个断言函数或可调用对象到范围中的每个元素，并返回 true 一旦找到使断言函数返回 true 的元素，否则如果范围中的所有元素都不满足条件，则返回 false。

std::any_of 有两个版本：默认版本和自定义断言版本。
默认版本

默认版本的 std::any_of 接受两个迭代器表示范围的开始和结束，以及一个断言函数或可调用对象。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用 std::any_of 检查是否有任何元素是偶数
    bool hasEven = std::any_of(numbers.begin(), numbers.end(), [](int n) {
        return n % 2 == 0;
    });

    // 输出结果
    if (hasEven) {
        std::cout << "There are even numbers in the range." << std::endl;
    } else {
        std::cout << "There are no even numbers in the range." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个 lambda 表达式来检查一个整数是否是偶数。std::any_of 应用这个 lambda 表达式到 numbers 向量中的每个元素，一旦找到至少一个偶数，就返回 true。
自定义断言版本

你也可以提供一个自定义的断言函数作为 std::any_of 的第三个参数。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义断言函数，检查一个整数是否大于某个值
bool isGreaterThanThree(int n) {
    return n > 3;
}

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用自定义断言函数检查是否有任何元素大于3
    bool hasGreaterThanThree = std::any_of(numbers.begin(), numbers.end(), isGreaterThanThree);

    // 输出结果
    if (hasGreaterThanThree) {
        std::cout << "There are numbers greater than 3 in the range." << std::endl;
    } else {
        std::cout << "There are no numbers greater than 3 in the range." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个名为 isGreaterThanThree 的函数，它检查一个整数是否大于 3。然后，我们将这个函数作为 std::any_of 的第三个参数，以检查 numbers 向量中是否有任何元素大于 3。因为 4 和 5 都大于 3，所以 std::any_of 返回 true。

这两种版本（默认和自定义断言）的用法都非常灵活，可以根据需要选择使用 lambda 表达式还是自定义函数来定义检查条件。

none_of()

std::none_of 是 C++ 标准库中的一个算法，用于检查给定范围内的元素是否都不满足某个条件。换句话说，它验证是否没有一个元素使给定的断言函数或可调用对象返回 true。如果范围内没有元素满足条件，std::none_of 返回 true，否则返回 false。
默认版本

默认版本的 std::none_of 接受两个迭代器表示范围的开始和结束，以及一个断言函数或可调用对象。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用 std::none_of 检查是否没有任何元素是偶数
    bool noEvenNumbers = std::none_of(numbers.begin(), numbers.end(), [](int n) {
        return n % 2 == 0;
    });

    // 输出结果
    if (noEvenNumbers) {
        std::cout << "There are no even numbers in the range." << std::endl;
    } else {
        std::cout << "There are even numbers in the range." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个 lambda 表达式来检查一个整数是否是偶数。std::none_of 应用这个 lambda 表达式到 numbers 向量中的每个元素。因为 numbers 向量中至少有一个元素（即 2）是偶数，所以 std::none_of 返回 false。
自定义比较版本

你也可以提供一个自定义的比较函数作为 std::none_of 的第三个参数。

示例：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数，检查一个整数是否小于等于 3
bool isLessThanOrEqualToThree(int n) {
    return n <= 3;
}

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用自定义比较函数检查是否没有任何元素小于等于 3
    bool noElementLessThanOrEqualToThree = std::none_of(numbers.begin(), numbers.end(), isLessThanOrEqualToThree);

    // 输出结果
    if (noElementLessThanOrEqualToThree) {
        std::cout << "There are no numbers less than or equal to 3 in the range." << std::endl;
    } else {
        std::cout << "There are numbers less than or equal to 3 in the range." << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个名为 isLessThanOrEqualToThree 的函数，它检查一个整数是否小于或等于 3。然后，我们将这个函数作为 std::none_of 的第三个参数，以检查 numbers 向量中是否有任何元素小于或等于 3。因为 numbers 向量中有多个元素（即 1、2、3）满足这个条件，所以 std::none_of 返回 false。

这两个版本（默认和自定义比较）都允许你灵活地使用 lambda 表达式或自定义函数来定义检查条件，以便确定范围内是否有元素满足该条件。

熊猫Devin
关注
  • 24
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一些C++ STL泛型算法整理
yibo_ge的博客
04-04 1314
泛型算法本身不会执行容器的的操作，他们只会运行于迭代器上，执行迭代器的操作。所以算法永远不会改变底层容器的大小，但可能改变容器中元素的值，也可能在容器中移动元素，但永远不会直接添加和删除元素。但标准库定义了一类特殊的迭代器，称为插入迭代器，这种迭代器赋值是，他们会在底层容器上执行插入操作。因此算法可以利用插入迭代器完成向容器中添加元素的操作，但算法本身永远不会做这样的操作。 大多数算法都定义在头
C++泛型算法的一些总结
09-05
C++泛型算法是编程语言中的一类重要工具，它们提供了高效、通用的处理数据序列的方法，不依赖于特定的数据结构或元素类型。这些算法独立于容器，仅依赖于元素的比较操作，使得代码更加灵活且易于重用。在本文中，...
C++//泛型算法
weixin_43918519的博客
03-29 1212
1. 初识泛型算法 泛型：可以作用于不同类型的元素和多种容器类型 算法：实现了一些经典算法诸如排序和搜索的接口。 泛型算法运行于迭代器之上，不会执行容器的操作。由此得出假定：泛型算法永远不会改变底层容器的大小。 输入范围：标准库算法都对一个范围内的元素进行操作，该范围称为输入范围。如果算法接受输入范围作为参数，通常用前两个参数表示范围，即第一个元素和尾后元素的迭代器。 大多数算法存储在algorithm头文件内，numeric中定义了一组数值泛型算法。 1.1 只读算法 只会读取输入范围中的元素，而不会改变
C++ 泛型算法
Super-Father
12-13 872
一、泛型算法的基本概念 所有容器类型的公共操作，组成的泛型算法集合，能够被应用到容器类型以及内置数组上。 所需的头文件是：#include <algorithm> 二、泛型算法中的find与内置数组 以下实例实现了使用find查找并且返回数组中的元素地址: #include <iostream> #include <vector> #include <algorithm> #include <time.h> using namespace s
C++泛型算法
陨星落云的博客
04-01 1300
泛型算法 泛型算法：可以支持多种类型的算法 这里重点讨论 C++ 标准库中定义的算法 ● <algorithm> <numeric> <ranges> 例1：打印输出 #include <iostream> #include <vector> #include <algorithm> void PrintFunc(int x) { std::cout << x << " "; } int main() {
C++ 常用泛型算法整理
学习侠的博客
07-30 608
C++标准库提供了很多好用的泛型算法，这里整理几个我自己爱用的算法，主要参考《C++ Primer》。
C++算法与泛型算法（algorithm、numeric）
08-25
C++算法与泛型算法 C++算法与泛型算法是一种强大的工具，用于操作容器中的元素。这些算法可以分为三类：只读算法、写算法和重排元素算法。下面将对这些算法进行详细的介绍。 一、算法简介 大多数算法在头文件`...
算法岗位之c++部分面试准备6面向对象与泛型编程
01-08
右值引用(&&)是C++11中引入的新特性 , 它实现了转移语义和精确传递。它的主要目的有两个方面： 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。 能够更简洁明确地定义泛型函数。 左值和右值的...
算法力扣刷题记录 五十九【450.删除二叉搜索树中的节点】
danaaaa的博客
07-25 1245
删除节点，在左右子树不为空的情况，处理稍微复杂。
代码随想录算法训练营第二十二天|回溯算法part01
qq_43456971的博客
07-25 704
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1295
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
大模型算法备案流程最详细说明【流程+附件】
cybtec的博客
07-25 961
大模型备案,模型服务协议 1.大模型备案 2.大模型算法备案 3.大模型网信办备案 4.网信办大模型备案 5.AI大模型备案制度 6.大模型 备案 7.大模型备案要求 8.大模型备案管理制度 9.算法备案和大模型备案区别
代码随想录算法训练营第22天-leetcode-回溯算法part01：
weixin_65180740的博客
07-25 1116
column的赋值过程：*column是正常数组，先为*column开辟空间，*column【第几个，<returnsize】=ans【第几个】有多少个二层元素。示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4],放入path的过程需要用循环一个个放入，直接=path的话，后面会随path修改而修改。示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1653
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
学习C语言第12天（数组练习）
2301_79600945的博客
07-24 553
把任意数字从中间拆分拆分后的乘积之和等于自身，则是一个水仙花。例如：655=6*55+65*5。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 2851
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
2024秋招算法
weixin_43364551的博客
07-22 2105
根据代码随想录和力扣进行算法训练的笔记
算法 —— 暴力枚举
最新发布
fen_0108的博客
07-25 3391
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
力扣621.任务调度器
Pisasama的博客
07-25 306
【代码】力扣621.任务调度器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊猫Devin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值