【C++提高编程-11】----C++ STL常用集合算法

news2024/11/23 17:04:49

🎩 欢迎来到技术探索的奇幻世界👨‍💻

📜 个人主页：@一伦明悦-CSDN博客

✍🏻 作者简介： C++软件开发、Python机器学习爱好者

🗣️ 互动与支持：💬评论      👍🏻点赞      📂收藏     👀关注+

如果文章有所帮助，欢迎留下您宝贵的评论，

点赞加收藏支持我，点击关注，一起进步！

前言

    在C++ STL（标准模板库）中，有几个常用的集合算法可以用来操作集合（如std::set或std::unordered_set）：

正文

01-常用集合算法之set_intersection用法

       std::set_intersection是一个C++标准库中用于计算两个已排序范围的交集的算法。它将交集的结果存储在第三个范围中，这个范围必须事先被分配足够的空间来存储结果。

以下是std::set_intersection的典型用法和详细解释：

#include <algorithm> // for std::set_intersection
#include <vector>    // for std::vector
#include <iostream>  // for output

int main() {
    // 定义两个已排序的输入集合
    std::vector<int> set1 = {1, 2, 3, 4, 5};
    std::vector<int> set2 = {3, 4, 5, 6, 7};

    // 定义一个输出集合，用于存储交集结果
    std::vector<int> intersection;

    // 使用 std::back_inserter 来避免手动管理容量
    // std::set_intersection 会根据需要自动增加 intersection 的容量
    std::set_intersection(set1.begin(), set1.end(),
                          set2.begin(), set2.end(),
                          std::back_inserter(intersection));

    // 输出交集结果
    for (int num : intersection) {
        std::cout << num << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在上面的代码中，我们定义了两个已排序的std::vector集合set1和set2。然后我们使用std::set_intersection算法来计算它们的交集，并将结果存储在另一个std::vector``intersection中。

std::set_intersection的参数解释：

  1. set1.begin()和set1.end()：这些是set1的开始和结束迭代器，它们定义了第一个输入范围的边界。

  2. set2.begin()和set2.end()：这些是set2的开始和结束迭代器，它们定义了第二个输入范围的边界。

  3. std::back_inserter(intersection)：这是一个输出

下面给出具体代码分析应用过程：

这段代码演示了如何使用 std::set_intersection 算法来计算两个向量 v1 和 v2 的交集，并将结果存储在目标向量 vTarget 中。

让我们逐步解释这段代码：

  1. 头文件包含和命名空间：

    #include <vector>
#include <algorithm>
#include <iostream> // 没有在代码中显示，但通常需要用来输出
using namespace std;

    这些头文件包含了向量 (vector) 和算法 (algorithm) 所需的标准库内容，并使用了 std 命名空间。

  2. 自定义函数对象 myPrint：

    class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

    myPrint 是一个函数对象类，它定义了 operator()，用于打印整数值。这个类在后面的代码中被用来遍历并打印向量的元素。

  3. 测试函数 test01：

    void test01()
{
    vector<int> v1;
    vector<int> v2;
    
    // 向 v1 和 v2 中添加元素
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);      // v1 包含 0 到 9
        v2.push_back(i + 5);  // v2 包含 5 到 14
    }
    
    vector<int> vTarget;
    // 取两个向量中较小的大小来设置 vTarget 的大小
    vTarget.resize(min(v1.size(), v2.size()));
    
    // 使用 std::set_intersection 计算交集，并将结果存储在 vTarget 中
    vector<int>::iterator itEnd =
        set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    // 使用自定义的 myPrint 函数对象打印 vTarget 中的元素
    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;
}
    • test01 函数首先创建两个向量 v1 和 v2，分别包含了一系列整数。
    • v1 包含了 {0, 1, 2, ..., 9}，v2 包含了 {5, 6, 7, ..., 14}。
    • vTarget 向量被预先调整大小为 min(v1.size(), v2.size())，以确保足够存储计算得到的交集。
    • set_intersection 函数被调用来计算 v1 和 v2 的交集，结果存储在 vTarget 中。返回值 itEnd 是输出范围的尾后迭代器。
    • for_each 算法结合 myPrint 函数对象，迭代输出 vTarget 中的元素。

  4. 主函数 main：

    int main() {
    test01();
    system("pause");
    return 0;
}
    • main 函数调用 test01 来执行测试，并在程序结束时暂停控制台，以便查看输出结果。

总结：这段代码展示了如何使用 std::set_intersection 计算两个向量的交集，并使用自定义函数对象来打印结果。这种方法利用了 C++ 标准库中的算法和容器，展示了如何高效地处理集合操作。


#include <vector>
#include <algorithm>
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int> vTarget;
	//取两个里面较小的值给目标容器开辟空间
	vTarget.resize(min(v1.size(), v2.size()));
	//返回目标容器的最后一个元素的迭代器地址
	vector<int>::iterator itEnd =
		set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

02-常用集合算法之set_union用法

       std::set_union 是另一个 C++ 标准库中的算法，用于计算两个已排序集合的并集。它会将两个输入集合的并集存储在第三个容器中，这个容器必须足够大以容纳所有结果。

以下是 std::set_union 的典型用法和详细解释：

#include <algorithm> // for std::set_union
#include <vector>    // for std::vector
#include <iostream>  // for output

int main() {
    // 定义两个已排序的输入集合
    std::vector<int> set1 = {1, 2, 3, 4, 5};
    std::vector<int> set2 = {3, 4, 5, 6, 7};

    // 定义一个输出集合，用于存储并集结果
    std::vector<int> unionResult(set1.size() + set2.size());

    // 使用 std::set_union 计算并集，并返回结束迭代器
    auto itEnd = std::set_union(set1.begin(), set1.end(),
                                set2.begin(), set2.end(),
                                unionResult.begin());

    // 调整输出集合大小，仅包含有效元素
    unionResult.resize(itEnd - unionResult.begin());

    // 输出并集结果
    for (int num : unionResult) {
        std::cout << num << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这段代码中，我们展示了如何使用 std::set_union 算法计算两个已排序向量 set1 和 set2 的并集，并将结果存储在另一个向量 unionResult 中。

std::set_union 的参数解释：

  1. 输入集合的迭代器范围：

    • set1.begin() 和 set1.end()：定义第一个输入集合 set1 的开始和结束迭代器。
    • set2.begin() 和 set2.end()：定义第二个输入集合 set2 的开始和结束迭代器。

  2. 输出集合的目标范围：

    • unionResult.begin()：指定用于存储结果的输出集合的起始位置迭代器。

  3. 返回值：

    • std::set_union 函数返回一个迭代器，指向输出范围的结束位置。这个迭代器可以帮助我们调整输出容器的大小，使其仅包含有效的并集元素。

代码解析：

  • 定义输入集合：set1 和 set2 是已排序的向量，分别包含 {1, 2, 3, 4, 5} 和 {3, 4, 5, 6, 7}。

  • 定义输出集合：unionResult 的大小被设定为 set1.size() + set2.size()，以确保足够大来容纳所有可能的并集元素。

  • 计算并集：std::set_union 函数被调用来计算 set1 和 set2 的并集，并将结果存储在 unionResult 中。结束迭代器 itEnd 标志着输出范围的末尾。

  • 调整输出集合大小：通过 unionResult.resize(itEnd - unionResult.begin())，我们调整 unionResult 的大小，使其仅包含实际计算得到的并集元素。

  • 输出结果：最后使用简单的循环输出来展示计算得到的并集。

总结来说，std::set_union 是一个有用的算法，用于合并两个已排序集合，其操作简便高效，适用于各种需要处理集合并集的情况。

下面给出具体代码分析应用过程：

这段代码演示了如何使用 std::set_union 算法来计算两个向量 v1 和 v2 的并集，并将结果存储在目标向量 vTarget 中。

让我们逐步解释这段代码：

  1. 头文件包含和命名空间：

    #include <vector>
#include <algorithm>
using namespace std;

    这些头文件包含了向量 (vector) 和算法 (algorithm) 所需的标准库内容，并使用了 std 命名空间。

  2. 自定义函数对象 myPrint：

    class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

    myPrint 是一个函数对象类，它定义了 operator()，用于打印整数值。这个类在后面的代码中被用来遍历并打印向量的元素。

  3. 测试函数 test01：

    void test01()
{
    vector<int> v1;
    vector<int> v2;
    
    // 向 v1 和 v2 中添加元素
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);      // v1 包含 0 到 9
        v2.push_back(i + 5);  // v2 包含 5 到 14
    }
    
    vector<int> vTarget;
    // 取两个容器的和给目标容器开辟空间
    vTarget.resize(v1.size() + v2.size());
    
    // 使用 std::set_union 计算并集，并将结果存储在 vTarget 中
    vector<int>::iterator itEnd =
        set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    // 使用自定义的 myPrint 函数对象打印 vTarget 中的元素
    for_each(vTarget.begin(), itEnd, myPrint());
#include <vector>
#include <algorithm>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int> vTarget;
	//取两个容器的和给目标容器开辟空间
	vTarget.resize(v1.size() + v2.size());
	//返回目标容器的最后一个元素的迭代器地址
	vector<int>::iterator itEnd =
		set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

03-常用集合算法之set_difference用法

       std::set_difference 是另一个C++标准库中的算法，用于计算两个已排序集合的差集。它会从第一个输入集合中移除与第二个输入集合相同的元素，并将结果存储在第三个容器中。以下是 std::set_difference 的典型用法和详细解释：

#include <algorithm> // for std::set_difference
#include <vector>    // for std::vector
#include <iostream>  // for output

int main() {
    // 定义两个已排序的输入集合
    std::vector<int> set1 = {1, 2, 3, 4, 5};
    std::vector<int> set2 = {3, 4, 5, 6, 7};

    // 定义一个输出集合，用于存储差集结果
    std::vector<int> differenceResult(set1.size());

    // 使用 std::set_difference 计算差集，并返回结束迭代器
    auto itEnd = std::set_difference(set1.begin(), set1.end(),
                                     set2.begin(), set2.end(),
                                     differenceResult.begin());

    // 调整输出集合大小，仅包含有效元素
    differenceResult.resize(itEnd - differenceResult.begin());

    // 输出差集结果
    for (int num : differenceResult) {
        std::cout << num << ' ';
    }
    std::cout << std::endl;

    return 0;
}

std::set_difference 的参数解释：

  1. 输入集合的迭代器范围：

    • set1.begin() 和 set1.end()：定义第一个输入集合 set1 的开始和结束迭代器。
    • set2.begin() 和 set2.end()：定义第二个输入集合 set2 的开始和结束迭代器。

  2. 输出集合的目标范围：

    • differenceResult.begin()：指定用于存储结果的输出集合的起始位置迭代器。

  3. 返回值：

    • std::set_difference 函数返回一个迭代器，指向输出范围的结束位置。这个迭代器可以帮助我们调整输出容器的大小，使其仅包含有效的差集元素。

代码解析：

  • 定义输入集合：set1 和 set2 是已排序的向量，分别包含 {1, 2, 3, 4, 5} 和 {3, 4, 5, 6, 7}。

  • 定义输出集合：differenceResult 的大小被设定为 set1.size()，以确保足够大来容纳所有可能的差集元素。

  • 计算差集：std::set_difference 函数被调用来计算 set1 和 set2 的差集，并将结果存储在 differenceResult 中。结束迭代器 itEnd 标志着输出范围的末尾。

  • 调整输出集合大小：通过 differenceResult.resize(itEnd - differenceResult.begin())，我们调整 differenceResult 的大小，使其仅包含实际计算得到的差集元素。

  • 输出结果：最后使用简单的循环输出来展示计算得到的差集。

总结来说，std::set_difference 是一个有用的算法，用于从一个已排序集合中移除另一个集合中存在的元素，其操作简便高效，适用于各种需要处理集合差集的情况。

 下面给出具体代码分析应用过程：

这段代码展示了如何使用 std::set_difference 算法来计算两个已排序向量 v1 和 v2 的差集，并将结果存储在目标向量 vTarget 中。

让我们逐步解释这段代码：

  1. 头文件包含和命名空间：

    #include <vector>
#include <algorithm>
#include <iostream>  // 这里应该包含头文件以便使用 cout
using namespace std;

    这些头文件包含了向量 (vector) 和算法 (algorithm) 所需的标准库内容，以及输出 (cout) 所需的头文件。

  2. 自定义函数对象 myPrint：

    class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

    myPrint 是一个函数对象类，用于打印整数值。它在后面的代码中被用来遍历并打印向量的元素。

  3. 测试函数 test01：

    void test01()
{
    vector<int> v1;
    vector<int> v2;
    
    // 向 v1 和 v2 中添加元素
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);      // v1 包含 0 到 9
        v2.push_back(i + 5);  // v2 包含 5 到 14
    }
    
    vector<int> vTarget;
    
    // 取两个向量中较大的大小作为目标容器的大小
    vTarget.resize(max(v1.size(), v2.size()));
    
    // 使用 std::set_difference 计算 v1 和 v2 的差集，并将结果存储在 vTarget 中
    cout << "v1与v2的差集为： " << endl;
    vector<int>::iterator itEnd =
        set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    // 使用自定义的 myPrint 函数对象打印 vTarget 中的元素
    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;
    
    // 再次使用 set_difference 计算 v2 和 v1 的差集，并存储在 vTarget 中
    cout << "v2与v1的差集为： " << endl;
    itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    
    // 使用自定义的 myPrint 函数对象打印 vTarget 中的元素
    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;
}
    • 向量初始化：v1 和 v2 分别初始化为 {0, 1, 2, ..., 9} 和 {5, 6, 7, ..., 14}。
    • 目标向量初始化：vTarget 通过 resize 函数调整为能容纳 v1 和 v2 中最大元素数量的大小。
    • 第一次差集计算：使用 set_difference 计算 v1 和 v2 的差集，并将结果存储在 vTarget 中，通过 for_each 和 myPrint 打印差集元素。
    • 第二次差集计算：再次使用 set_difference 计算 v2 和 v1 的差集，并覆盖 vTarget，再次打印差集元素。

  4. 主函数 main：

    int main() {
    test01();
    system("pause");
    return 0;
}
    • 调用 test01 函数来执行测试。
    • 使用 system("pause") 来在控制台中暂停，以便查看输出结果。

这段代码通过 std::set_difference 演示了如何计算两个向量的差集，并通过自定义的函数对象来打印结果。

#include <vector>
#include <algorithm>
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int> vTarget;
	//取两个里面较大的值给目标容器开辟空间
	vTarget.resize(max(v1.size(), v2.size()));
	//返回目标容器的最后一个元素的迭代器地址
	cout << "v1与v2的差集为： " << endl;
	vector<int>::iterator itEnd =
		set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
	cout << "v2与v1的差集为： " << endl;
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结

       

  1. std::set_intersection（求交集）：

    • std::set_intersection算法用于计算两个已排序范围的交集，并将结果存储到另一个输出迭代器指定的范围中。
    • 示例用法： 
      std::set<int> set1 = {1, 2, 3, 4, 5};
std::set<int> set2 = {3, 4, 5, 6, 7};
std::vector<int> intersection;

std::set_intersection(set1.begin(), set1.end(),
                      set2.begin(), set2.end(),
                      std::back_inserter(intersection));

// intersection 现在包含 {3, 4, 5}

  2. std::set_union（求并集）：

    • std::set_union算法用于计算两个已排序范围的并集，并将结果存储到另一个输出迭代器指定的范围中。
    • 示例用法： 
      std::set<int> set1 = {1, 2, 3, 4, 5};
std::set<int> set2 = {3, 4, 5, 6, 7};
std::vector<int> uni;

std::set_union(set1.begin(), set1.end(),
               set2.begin(), set2.end(),
               std::back_inserter(uni));

// uni 现在包含 {1, 2, 3, 4, 5, 6, 7}

  3. std::set_difference（求差集）：

    • std::set_difference算法用于计算第一个已排序范围中存在但不在第二个已排序范围中的元素，并将结果存储到另一个输出迭代器指定的范围中。
    • 示例用法： 
      std::set<int> set1 = {1, 2, 3, 4, 5};
std::set<int> set2 = {3, 4, 5, 6, 7};
std::vector<int> difference;

std::set_difference(set1.begin(), set1.end(),
                    set2.begin(), set2.end(),
                    std::back_inserter(difference));

// difference 现在包含 {1, 2}

这些算法要求其输入范围是已排序的。如果输入集合不是已排序的，你需要先对它们进行排序，然后再应用这些算法。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1850459.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

vscode插件path-intellisense失效原因

vscode插件path-intellisense失效原因

很可能是因为设置中的自动补全部分除了问题。 问题 作者自身是因为使用了copilot之后&#xff0c;感觉vscod自带的自动补全(设置里面叫"建议"&#xff0c;或者inttelisense)就没必要了&#xff0c;然后一通改设置把建议关掉之后发现插件path-intellisense也不能用了…
阅读更多...
CATIA_DELMIA_V5R2019安装包下载及安装教程破解

CATIA_DELMIA_V5R2019安装包下载及安装教程破解

以下为V5-6R2019安装说明 1.将两卷安装文件解压到同一目录内&#xff0c;互相覆盖即可 &#xff08;按用户需要下载 CATIA 或者DELMIA&#xff09; 以上为 CATIA 的安装包 以上为 DELMIA 的安装包 两者合并到一起&#xff0c;同一目录 2.解压后运行setup.exe 如遇到报错&…
阅读更多...
[信号与系统]关于LTI系统的转换方程、拉普拉斯变换和z变换

[信号与系统]关于LTI系统的转换方程、拉普拉斯变换和z变换

前言 本文还是作为前置知识。 LTI系统的传递函数 LTI系统的传递函数 H ( z ) H(z) H(z) 是输出信号的z变换 Y ( z ) Y(z) Y(z) 与输入信号的z变换 X ( z ) X(z) X(z) 的比值&#xff1a; H ( z ) Y ( z ) X ( z ) H(z) \frac{Y(z)}{X(z)} H(z)X(z)Y(z)​ 多项式比值表…
阅读更多...
【实战分享】雷池社区版助力构建高可用、安全的Web应用架构

【实战分享】雷池社区版助力构建高可用、安全的Web应用架构

引言 在日益复杂的网络环境中&#xff0c;构建坚不可摧的安全防线成为每一位网站守护者的重要使命。本文将深入剖析一套集CDN加速、高效Nginx代理与雷池WAF深度防护于一体的现代网站安全架构设计&#xff0c;特别强调雷池WAF在此架构中的核心作用及其对整体安全性的提升策略。…
阅读更多...
作为一名程序员，怎么才能写出简洁实用还漂亮的代码楼呢？这25个超惊艳的Python代码写法，你一定要学会！

作为一名程序员，怎么才能写出简洁实用还漂亮的代码楼呢？这25个超惊艳的Python代码写法，你一定要学会！

前言 Python可以用于复杂的数据分析和Web开发项目&#xff0c;还能以极少的代码行数完成令人惊叹的任务。本文将分享25个简短的Python代码示例&#xff0c;用来展示Python编程语言的魅力和效率。 1.列表推导式 Python的列表推导式提供了一种优雅的方法来创建列表。 # 将一个…
阅读更多...
渗透测试-若依框架的杀猪交易所系统管理后台

渗透测试-若依框架的杀猪交易所系统管理后台

前言 这次是带着摸鱼的情况下简单的写一篇文章&#xff0c;由于我喜欢探究黑灰产业&#xff0c;所以偶尔机遇下找到了一个加密H币的交易所S猪盘&#xff0c;我记得印象是上年的时候就打过这一个同样的站&#xff0c;然后我是通过指纹查找其它的一些站&#xff0c;那个站已经关…
阅读更多...
高通安卓12-在源码中查找应用的方法

高通安卓12-在源码中查找应用的方法

1.通过搜索命令查找app 一般情况下&#xff0c;UI上看到的APP名称会在xml文件里面定义出来&#xff0c;如 搜索名字为WiGig的一个APP 执行命令 sgrep "WiGig" 2>&1|tee 1.log 将所有的搜索到的内容打印到log里面 Log里面会有一段内容 在它的前面是这段内…
阅读更多...
针对 AI 优化数据湖仓一体：使用 MinIO 仔细了解 RisingWave

针对 AI 优化数据湖仓一体：使用 MinIO 仔细了解 RisingWave

RisingWave 是现代数据湖仓一体处理层中的开源流数据库&#xff0c;专为性能和可扩展性而构建。RisingWave 旨在允许开发人员在流数据上运行 SQL。鉴于 SQL 是数据工程的通用语言&#xff0c;此功能非常重要。它具有强大的架构&#xff0c;包括计算节点、元节点和压缩器节点&am…
阅读更多...
Docker可视化web工具

Docker可视化web工具

docker run --restart always --name docker.ui -d -v /var/run/docker.sock:/var/run/docker.sock -p 8989:8999 joinsunsoft/docker.ui #--restart always&#xff1a;重启策略&#xff0c;只要关闭就会重启 http://192.168.10.51:8989 账号&#xff1a;ginghan 密码&#xf…
阅读更多...
ruoyi添加自己的菜单

ruoyi添加自己的菜单

先把自己自定义的view填写好 在菜单管理模块 因为我已经新增过&#xff0c;所以就看看我填的啥就行了 我发现一个问题&#xff0c;路由地址可以填index2或者scooldemo/index2都可以&#xff08;这个包含了文件夹路径&#xff09;&#xff0c;反正组件路径一定要填对就可以了。 …
阅读更多...
Stable Diffusion 插件安装与推荐，助力你的AI绘图

Stable Diffusion 插件安装与推荐，助力你的AI绘图

在上一篇文章我们安装了Stable Diffusion &#xff0c;这篇文章我们来安装Stable Diffusion的插件 Stable Diffusion的插件是绘画中重要的一环&#xff0c;好的插件可以让你的绘画更加得心应手 中英双语插件 为什么要安装中英双语插件呢&#xff0c;不能只安装中文插件吗&…
阅读更多...
Android内核编译

Android内核编译

前言 本文描述使用Ubuntu 编译Android内核刷入pixel4一些心得和流程。 PC信息&#xff1a; ./o- jackjackyyyyy- -yyyyyy OS: Ubuntu 22.04 jammy:////-yyyyyyo Kernel: x86_64 Linux 6.5.0-35-generic. .://-.sss/ Uptime: 1d 5h 4m.:o: //:--:/- …
阅读更多...
基于AT89C52单片机的温度报警系统

基于AT89C52单片机的温度报警系统

点击链接获取Keil源码与Project Backups仿真图： https://download.csdn.net/download/qq_64505944/89456321?spm=1001.2014.3001.5503 仿真构造：AT89C52+DS18B20温度模块+三按键+蜂鸣器+四位数码管显示+电源模块。 压缩包构造：源码+仿真图+设计文档+原理图+开题文档+元件…
阅读更多...
Apple - Cryptographic Services Guide

Apple - Cryptographic Services Guide

本文翻译自&#xff1a;Cryptographic Services Guide&#xff08;更新时间&#xff1a;2018-06-04 https://developer.apple.com/library/archive/documentation/Security/Conceptual/cryptoservices/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011172 文章目录…
阅读更多...
Stable Diffusion部署教程，开启你的AI绘图之路

Stable Diffusion部署教程，开启你的AI绘图之路

本文环境 系统&#xff1a;Ubuntu 20.04 64位 内存&#xff1a;32G 环境安装 2.1 安装GPU驱动 在英伟达官网根据显卡型号、操作系统、CUDA等查询驱动版本。官网查询链接https://www.nvidia.com/Download/index.aspx?langen-us 注意这里的CUDA版本&#xff0c;如未安装CUD…
阅读更多...
Open WebUI – 本地化部署大模型仿照 ChatGPT用户界面

Open WebUI – 本地化部署大模型仿照 ChatGPT用户界面

Open WebUI介绍&#xff1a; Open WebUI 是一个仿照 ChatGPT 界面&#xff0c;为本地大语言模型提供图形化界面的开源项目&#xff0c;可以非常方便的调试、调用本地模型。你能用它连接你在本地的大语言模型&#xff08;包括 Ollama 和 OpenAI 兼容的 API&#xff09;&#xf…
阅读更多...
物理层（二）

物理层（二）

2.2 传输介质 2.2.1 双绞线、同轴电缆、光纤和无线传输介质 传输介质也称传输媒体&#xff0c;是数据传输系统中发送器和接收器之间的物理通路。传输介质可分为:①导向传输介质&#xff0c;指铜线或光纤等&#xff0c;电磁波被导向为沿着固体介质传播:②)非导向传输介质&…
阅读更多...
Python武器库开发-武器库篇之ThinkPHP 2.x 任意代码执行漏洞（六十三）

Python武器库开发-武器库篇之ThinkPHP 2.x 任意代码执行漏洞（六十三）

Python武器库开发-武器库篇之ThinkPHP 2.x 任意代码执行漏洞&#xff08;六十三&#xff09; PHP代码审计简介 PHP代码审计是指对PHP程序进行安全审计&#xff0c;以发现潜在的安全漏洞和风险。PHP是一种流行的服务器端脚本语言&#xff0c;广泛用于开发网站和Web应用程序。由…
阅读更多...
Linux 内核权限提升漏洞CVE-2024-1086三种修复方法

Linux 内核权限提升漏洞CVE-2024-1086三种修复方法

作者介绍&#xff1a;老苏&#xff0c;10余年DBA工作运维经验&#xff0c;擅长Oracle、MySQL、PG数据库运维&#xff08;如安装迁移&#xff0c;性能优化、故障应急处理等&#xff09; 公众号&#xff1a;老苏畅谈运维 欢迎关注本人公众号&#xff0c;更多精彩与您分享。一、漏…
阅读更多...
任务3.8.4 利用RDD实现分组排行榜

任务3.8.4 利用RDD实现分组排行榜

文章目录 1. 任务说明2. 解决思路3. 准备成绩文件4. 采用交互式实现5. 采用Spark项目实战概述&#xff1a;使用Spark RDD实现分组排行榜任务背景任务目标技术选型实现步骤1. 准备数据2. 数据上传至HDFS3. 启动Spark Shell4. 读取数据生成RDD5. 数据处理6. 计算TopN7. 输出结果8…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023