【十四】【C++】list 的常见用法

list 的初始化和遍历

 
/*list的初始化和遍历*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;void TestList1(){list<int> L1;list<int> L2(10, 5);vector<int> v{1,2,3,4,5};list<int> L3(v.begin(), v.end());list<int> L4(L3);// C++11list<int> L5{ 1, 2, 3, 4, 5 };/// 链表遍历for (auto e : L2)cout << e << " ";cout << endl;// list<int>::iterator it = L3.begin();auto it = L3.begin();while (it != L3.end()){cout << *it << " ";++it;}cout << endl;auto rit = L4.rbegin();while (rit != L4.rend()){cout << *rit << " ";++rit;}cout << endl;// 注意：list不能使用原生态指针，即Node*来遍历链表// 因为list没有提供获取头指针的方法
}int main(){TestList1();}
#endif

d96b97f6d3ee43cabc19248b44f8e51e.png

std::list 是一个双向链表，提供了双向序列的特性，包括有效地进行插入、删除操作等，但不支持随机访问。

初始化 std::list

空初始化： list<int> L1; 创建了一个空的 int 类型的 list。

填充初始化： list<int> L2(10, 5); 创建了一个包含 10 个元素，每个元素都初始化为 5 的 list。

范围初始化： list<int> L3(v.begin(), v.end()); 使用 vector<int> v 的迭代器范围来初始化 L3，即将 v 中的元素复制到 L3 中。

拷贝初始化： list<int> L4(L3); 使用另一个 list L3 来初始化 L4，复制 L3 的所有元素。

列表初始化 （C++11）: list<int> L5{ 1, 2, 3, 4, 5 }; 使用初始化列表直接初始化 L5。

链表遍历

范围 for 循环： 使用范围 for 循环遍历 L2，打印出其所有元素。这是 C++11 引入的一种简洁的遍历容器的方式。

使用迭代器： 通过迭代器 it 遍历 L3，同样打印出所有元素。std::list 提供的迭代器是双向迭代器。

使用反向迭代器： 通过反向迭代器 rit 遍历 L4，但这次是逆序打印出所有元素。反向迭代器从容器的末尾开始遍历至开始。

注意

代码中提到，“list不能使用原生态指针，即 Node*来遍历链表”，这是因为 std::list 的实现细节被抽象化了，用户无法像操作普通链表那样通过节点指针进行遍历或访问。std::list 提供了迭代器来抽象这些细节，使得操作更安全、更容易。

list 的 resize 操作探究

 
/*list的resize操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;void TestList2(){list<int> L{ 1, 2, 3, 4, 5 };cout << L.size() << endl;L.resize(10, 6);for (auto e : L)cout << e << " ";cout << endl;L.resize(20);for (auto e : L)cout << e << " ";cout << endl;L.resize(7);for (auto e : L)cout << e << " ";cout << endl;}int main(){TestList2();}
#endif

 

2f7e5c580ed04fe684331efa3a9b5b34.png

resize 方法用于调整链表的大小，即元素的数量。以下是对 TestList2 函数中各个操作的详细解释：

初始化 std::list

list<int> L{ 1, 2, 3, 4, 5 };

使用初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的 list。

调整大小并填充新元素

L.resize(10, 6);

调整 L 的大小至 10 个元素。由于新大小大于当前大小，resize 方法会添加额外的元素。在这个例子中，新增的元素被初始化为 6。因此，调整后的 list 包含元素 {1, 2, 3, 4, 5, 6, 6, 6, 6, 6}。

再次调整大小，使用默认值填充

L.resize(20);

这次 L 的大小被调整至 20 个元素。因为没有指定新元素的初始化值，新增的元素会被默认初始化。对于整数类型，这意味着它们被初始化为 0。现在，list 包含 {1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}。

减少 list 的大小

L.resize(7);

L 的大小被减少至 7 个元素。resize 方法会移除超出新大小的元素。因此，list 现在包含 {1, 2, 3, 4, 5, 6, 6}。

在每次调整大小之后，代码通过一个范围 for 循环遍历 L 并打印其所有元素，这样可以直观地看到 resize 操作的结果。

list 的插入删除操作探究

 
/*list的插入删除操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;void TestList3(){list<int> L{ 1, 2, 3, 4, 5 };L.push_back(6);L.push_back(7);L.push_back(8);L.push_back(9);cout << L.size() << endl;cout << L.front() << endl;cout << L.back() << endl;L.pop_back();L.pop_back();for (auto e : L)cout << e << " ";cout << endl;L.push_front(0);for (auto e : L)cout << e << " ";cout << endl;L.pop_front();for (auto e : L)cout << e << " ";cout << endl;L.insert(L.begin(), 0);auto pos = find(L.begin(), L.end(), 5);if (pos != L.end())L.insert(pos, 5, 8);int array[] = { 10, 20, 30, 40, 50 };L.insert(L.end(), array, array + sizeof(array) / sizeof(array[0]));}int main(){TestList3();}
#endif

80797022737a47aab4aa8bccc651420f.png

std::list 是一个双向链表，支持在任何位置高效插入和删除元素。

初始化 std::list

list<int> L{ 1, 2, 3, 4, 5 };

使用初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的链表 L。

添加元素到链表尾部

通过 push_back 方法，在链表的尾部依次添加了元素 6、7、8 和 9。

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

这些操作将 L 扩展为 {1, 2, 3, 4, 5, 6, 7, 8, 9}。

移除链表尾部的元素

通过 pop_back 方法移除了链表尾部的两个元素（8 和 9）。

L.pop_back();

L.pop_back();

L 现在包含 {1, 2, 3, 4, 5, 6, 7}。

在链表头部添加元素

通过 push_front 方法在链表的头部添加了元素 0。

L.push_front(0);

L 现在包含 {0, 1, 2, 3, 4, 5, 6, 7}。

移除链表头部的元素

通过 pop_front 方法移除了链表头部的元素 0。

L.pop_front();

L 恢复为 {1, 2, 3, 4, 5, 6, 7}。

在链表特定位置插入元素

首先，在链表的开始位置插入元素 0。

L.insert(L.begin(), 0);

然后，找到元素 5 的位置，并在该位置前插入五个 8。

auto pos = find(L.begin(), L.end(), 5);

if (pos != L.end())

L.insert(pos, 5, 8);

这使得 L 变为 {0, 1, 2, 3, 4, 8, 8, 8, 8, 8, 5, 6, 7}。

从数组中插入多个元素

通过 insert 方法，将一个整型数组 {10, 20, 30, 40, 50} 的所有元素插入到链表的末尾。

int array[] = { 10, 20, 30, 40, 50 };

L.insert(L.end(), array, array + sizeof(array) / sizeof(array[0]));

这将数组中的元素添加到了 L 的末尾，使得 L 最终包含 {0, 1, 2, 3, 4, 8, 8, 8, 8, 8, 5, 6, 7, 10, 20, 30, 40, 50}。

list 的 erase、assign 操作探究

 
/*list的erase、assign操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;void TestList4(){list<int> L{ 1, 2, 3, 4, 5 };L.push_back(6);L.push_back(7);L.push_back(8);L.push_back(9);L.erase(L.begin());L.erase(find(L.begin(), L.end(), 8));L.erase(L.begin(), L.end());    // clear();L.assign(10, 5);int array[] = { 10, 20, 30, 40, 50 };L.assign(array, array + sizeof(array) / sizeof(array[0]));}int main(){TestList4();}
#endif

803b55a31497485bb33cd62aa394bea5.png

初始链表的创建和元素添加

list<int> L{ 1, 2, 3, 4, 5 };

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

首先，通过初始化列表创建一个包含 {1, 2, 3, 4, 5} 的 list，然后依次添加元素 6、7、8 和 9 到链表的末尾，使得链表变为 {1, 2, 3, 4, 5, 6, 7, 8, 9}。

删除链表中的元素

L.erase(L.begin());

删除链表的第一个元素（1）。此时链表变为 {2, 3, 4, 5, 6, 7, 8, 9}。

L.erase(find(L.begin(), L.end(), 8));

使用 find 函数查找值为 8 的元素，并将其删除。此时链表变为 {2, 3, 4, 5, 6, 7, 9}。

L.erase(L.begin(), L.end()); // clear();

删除链表中从开始到结束的所有元素，相当于清空整个链表。这行代码实际上清空了链表，使其不包含任何元素。

重新分配链表内容

L.assign(10, 5);

assign 方法用于将链表的内容替换为指定数量（这里是 10）的重复元素（这里是 5）。执行这个操作后，链表包含了 10 个值为 5 的元素。

使用数组重新分配链表内容

int array[] = { 10, 20, 30, 40, 50 };

L.assign(array, array + sizeof(array) / sizeof(array[0]));

再次使用 assign 方法，但这次是用数组的元素来重新分配链表的内容。通过计算数组的大小，将整个 array 的内容赋值给链表 L。执行这个操作后，链表的内容变为 {10, 20, 30, 40, 50}。

list 的 remove、sort、unique、reverse 操作探究

 
/*list的remove、sort、unique、reverse操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
void TestList5() {list<int> L{ 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 1, 1};L.remove(1);L.sort();L.unique();L.reverse();}int main() {TestList5();}
#endif

626de949630242159a936d7e9536fb00.png

初始链表的创建

list<int> L{ 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 1, 1};

首先，通过初始化列表创建了一个包含重复元素的 list。

删除特定元素

L.remove(1);

remove 方法从链表中删除所有值为 1 的元素。执行这个操作后，链表中所有的 1 被移除，链表变为 {2, 3, 4, 5, 2, 3, 4, 5}。

对链表进行排序

L.sort();

sort 方法对链表中的元素进行排序。std::list 提供了自己的 sort 成员函数，因为标准算法库中的 std::sort 需要随机访问迭代器，而 list 只提供双向迭代器。排序后，链表变为 {2, 2, 3, 3, 4, 4, 5, 5}。

移除连续重复的元素

L.unique();

unique 方法移除链表中连续重复的元素，只保留了每组重复元素中的第一个元素。在排序后的链表中应用 unique，会移除所有的连续重复项，链表变为 {2, 3, 4, 5}。

反转链表

L.reverse();

reverse 方法将链表中的元素反向排列。执行这个操作后，链表中的元素顺序被反转，即 {5, 4, 3, 2}。

list 的 remove_if 操作探究

 
/*list的remove_if操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;bool IsEven(int data) {// 5的二进制：0000 0101//          0000 0001// return 0 == (data & 0x01);return 0 == data % 2;}void TestList6() {list<int> L{ 1, 2, 3, 4, 5 };L.push_back(6);L.push_back(7);L.push_back(8);L.push_back(9);L.remove_if(IsEven);}int main() {TestList6();}
#endif

3fa71dc98de64517ae95790ce1adf394.png

remove_if 方法允许用户指定一个谓词（一个返回布尔值的函数或函数对象），根据这个谓词来决定哪些元素应该被移除。

定义判定函数

bool IsEven(int data) {

return 0 == data % 2;

}

这个函数 IsEven 检查给定的整数是否为偶数。如果是偶数，返回 true；否则返回 false。

初始化 std::list 并添加元素

list<int> L{ 1, 2, 3, 4, 5 };

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

首先，通过初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的 list，然后依次添加了元素 6、7、8 和 9 到链表的末尾。

使用 remove_if 根据条件移除元素

L.remove_if(IsEven);

remove_if 方法接受一个谓词函数 IsEven 作为参数，并移除 L 中所有使得 IsEven 返回 true 的元素。在这个例子中，它会移除链表中所有的偶数。

执行 remove_if 之后，原始链表 {1, 2, 3, 4, 5, 6, 7, 8, 9} 中的偶数元素被移除，留下了 {1, 3, 5, 7, 9}。

list 的迭代器失效探究

 
/*list的迭代器失效探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;void TestList7() {list<int> L{ 1, 2, 3, 4, 5 };L.push_back(6);L.push_back(7);L.push_back(8);L.push_back(9);//1auto it = L.begin();L.pop_front();while (it != L.end()){cout << *it << " ";++it;}
//2L.resize(0);while (it != L.end()){cout << *it << " ";++it;}
//3L.assign(10, 5);list<int> L1{ 10, 20, 30, 40, 50 };L = L1;while (it != L.end()){cout << *it << " ";++it;}
//4while (it != L.end()) {// L.erase(it);// ++it;it = L.erase(it);}}int main() {TestList7();}
#endif

 

 

初始化列表和添加元素

list<int> L{ 1, 2, 3, 4, 5 };

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

这段代码初始化了一个包含 {1, 2, 3, 4, 5, 6, 7, 8, 9} 的 list。

删除链表的第一个元素

auto it = L.begin();

L.pop_front();

it 初始化为指向链表的第一个元素。随后，pop_front() 删除了链表的第一个元素。由于 it 此时指向的元素被删除，it 的状态变得未定义，导致迭代器失效。正确的做法是在删除操作之后重新获取 begin() 的迭代器。

52eb30ebdd304006b957ee71ae095ef7.png

清空链表

L.resize(0);

这段代码将链表的大小调整为 0，相当于清空了链表。此时，除了 end() 迭代器之外，任何其他迭代器都变得无效，包括之前的 it。

50e8144ebd1d4da98a40cdd2e3161cef.png

stl_list_h 中"operator ="底层代码

 
/*operator = 重载*/
template <class T, class Alloc>
list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x) {if (this != &x) {iterator first1 = begin();iterator last1 = end();const_iterator first2 = x.begin();const_iterator last2 = x.end();while (first1 != last1 && first2 != last2) *first1++ = *first2++;if (first2 == last2)erase(first1, last1);elseinsert(last1, first2, last2);}return *this;}

template <class T, class Alloclist<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x) {

这一行声明了一个模板函数，这个函数是list类的成员函数，用于重载赋值运算符=。T是列表中存储元素的类型，而Alloc是分配器类型，用于控制元素的内存分配。该函数接收一个常量引用x作为参数，这个参数是另一个list对象，表示要从中复制数据。函数返回对当前对象的引用，允许链式赋值。

if (this != &x) {

这一行检查自赋值的情况。如果被赋值的对象（*this）和赋值来源对象（x）是同一个对象，则不执行任何操作。这是为了防止自我复制时可能发生的资源泄露或不必要的操作。

iterator first1 = begin(); iterator last1 = end(); const_iterator first2 = x.begin(); const_iterator last2 = x.end();

这四行代码初始化四个迭代器。first1和last1分别是当前list对象的起始和结束位置的迭代器。first2和last2是参数x（即要复制的list对象）的起始和结束位置的常量迭代器。

while (first1 != last1 && first2 != last2) *first1++ = *first2++;

这行代码在两个列表都没有遍历完之前，逐个元素地从x复制元素到当前对象。*first1++ = *first2++这个表达式复制元素值，并将两个迭代器分别向前移动到下一个元素。

if (first2 == last2)erase(first1, last1);elseinsert(last1, first2, last2);

在完成上述循环后，会有两种情况：

如果x的元素已经复制完，但当前对象中还有剩余元素，这些剩余元素需要被删除。这通过调用erase(first1, last1)实现，它删除从first1到last1（不包括last1）范围内的所有元素。

如果当前对象的元素已经被完全覆盖，但x中还有未复制的元素，这些元素需要被插入到当前对象的末尾。这通过调用insert(last1, first2, last2)实现，它从first2到last2的范围内插入元素到last1位置之前。

return *this;

最后，函数返回当前对象的引用，使得可以进行链式赋值操作（例如，a = b = c）。

重新分配链表内容

L.assign(10, 5);

list<int> L1{ 10, 20, 30, 40, 50 };

L = L1;

05f453db694040959c799b1d7b5a02ea.png

assign底层实现和operator=大致是相同的。根据迭代器指向的位置元素是否被销毁来判断迭代器是否失效。示例代码迭代器没有发生失效。

删除操作

while (it != L.end()) {

it = L.erase(it);

}

6f1b7b56d82e48e59c2c050ec054f5bf.png

这种模式是正确的方式来删除链表中的元素，因为 erase 返回指向被删除元素下一个元素的迭代器。

 

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

 

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

 

谢谢您的支持，期待与您在下一篇文章中再次相遇！

 

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

精灵图，字体图标，CSS3三角

精灵图，字体图标，CSS3三角

精灵图 1.1为什么需要精灵图 一个网页中往往会应用很多小的背景图像作为修饰&#xff0c;当网页中的图像过多时&#xff0c;服务器就会频繁的接受和发送请求图片&#xff0c;造成服务器请求压力过大&#xff0c;这将大大降低页面的加载速度。 因此&#xff0c;为了有效地减少…
阅读更多...
【踏雪无痕的痕二】——小学一年级数学题窥探蝴蝶效应

【踏雪无痕的痕二】——小学一年级数学题窥探蝴蝶效应

目录 一、背景介绍二、思路&方案三、过程1.结果一致过程不一致带来的偏差2.再举两个例子&#xff0c;你品一品3.我曾经的培养计划背后的"力量"&#xff1f;4.蝴蝶效应——混沌或非线性理论什么是蝴蝶效应&#xff1f; 5.内心深处的小恶魔(人性的使然) 四、总结 一…
阅读更多...
Java基础知识总结（持续更新中）

Java基础知识总结（持续更新中）

Java基础知识&#xff08;持续更新&#xff09; 类型转化&#xff1a;数字、字符串、字符之间相互转化 数字 <-> 字符串 // 数字转字符串 // method1int number 5;String str String.valueOf(number);// method2int number 5;Integer itr number; //int装箱为对…
阅读更多...
使用耳机壳UV树脂制作一个耳机壳需要多长时间？

使用耳机壳UV树脂制作一个耳机壳需要多长时间？

使用耳机壳UV树脂制作一个耳机壳所需的时间取决于多个因素&#xff0c;包括工艺流程、加工方式、设备和技术水平等。一般来说&#xff0c;制作一个耳机壳需要数小时到数天不等。 以下是影响制作时间的几个主要因素&#xff1a; 获取耳模时间&#xff1a;获取耳模的时间取决于…
阅读更多...
数据库学习案例20240206-ORACLE NEW RAC agent and resource关系汇总。

数据库学习案例20240206-ORACLE NEW RAC agent and resource关系汇总。

1 集群架构图 整体集群架构图如下&#xff1a; 1 数据库启动顺序OHASD层面 操作系统进程init.ohasd run启动ohasd.bin init.ohasd run 集群自动启动是否被禁用 crsctl enable has/crsGIHOME所在文件系统是否被正常挂载。管道文件npohasd是否能够被访问&#xff0c; cd /var/t…
阅读更多...
口腔助手|口腔挂号预约小程序|基于微信小程序的口腔门诊预约系统的设计与实现(源码+数据库+文档)

口腔助手|口腔挂号预约小程序|基于微信小程序的口腔门诊预约系统的设计与实现(源码+数据库+文档)

口腔小程序目录 目录 基于微信小程序的口腔门诊预约系统的设计与实现 一、前言 二、系统功能设计 三、系统实现 1、小程序前台界面实现 2、后台管理员模块实现 四、数据库设计 1、实体ER图 2、具体的表设计如下所示&#xff1a; 五、核心代码 六、论文参考 七、最新…
阅读更多...
Spark安装（Yarn模式）

Spark安装（Yarn模式）

一、解压 链接&#xff1a;https://pan.baidu.com/s/1O8u1SEuLOQv2Yietea_Uxg 提取码&#xff1a;mb4h tar -zxvf /opt/software/spark-3.0.3-bin-hadoop3.2.tgz -C /opt/module/spark-yarn mv spark-3.0.3-bin-hadoop3.2/ spark-yarn 二、配置环境变量 vim /etc/profile…
阅读更多...
空气质量预测 | Matlab实现基于SVR支持向量机回归的空气质量预测模型

空气质量预测 | Matlab实现基于SVR支持向量机回归的空气质量预测模型

文章目录 效果一览文章概述源码设计参考资料效果一览 文章概述 政府机构使用空气质量指数 (AQI) 向公众传达当前空气污染程度或预测空气污染程度。 随着 AQI 的上升，公共卫生风险也会增加。 不同国家有自己的空气质量指数，对应不同国家的空气质量标准。 基于支持向量机（Su…
阅读更多...
【MATLAB源码-第138期】基于matlab的D2D蜂窝通信仿真，对比启发式算法，最优化算法和随机算法的性能。

【MATLAB源码-第138期】基于matlab的D2D蜂窝通信仿真，对比启发式算法，最优化算法和随机算法的性能。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 D2D蜂窝通信介绍 D2D蜂窝通信允许在同一蜂窝网络覆盖区域内的终端设备直接相互通信&#xff0c;而无需数据经过基站或网络核心部分转发。这种通信模式具有几个显著优点&#xff1a;首先&#xff0c;它可以显著降低通信延迟&…
阅读更多...
Day30 回溯算法part06

Day30 回溯算法part06

又是眼红别人的一天 重新安排行程 菜鸡思路&#xff1a;把从jfk往下所有的情况都列举出来&#xff0c;result数组包含五个元素的时候返回数组。 我们只需要找到一个行程&#xff0c;就是在树形结构中唯一的一条通向叶子节点的路线 N皇后 这个isValid函数也很不好想啊 首先…
阅读更多...
seata分布式事务

seata分布式事务

文章目录 1、分布式事务1.1 事务的ACID原则原子性一致性隔离性持久性 1.2 分布式事务的问题示例代码准备环境1. seata_demo数据库2. 启动nacos seata-demo父工程pom.xml order-servicepom.xmlapplication.ymlOrderApplicationOrderControllerOrderServiceImplAccountClientStor…
阅读更多...
Elasticsearch：通过 ingest pipeline 对大型文档进行分块

Elasticsearch：通过 ingest pipeline 对大型文档进行分块

在我之前的文章 “Elasticsearch&#xff1a;使用 LangChain 文档拆分器进行文档分块” 中&#xff0c;我详述了如何通过 LangChain 对大的文档进行分块。那个分块的动作是通过 LangChain 在 Python 中进行实现的。对于使用版权的开发者来说&#xff0c;我们实际上是可以通过 i…
阅读更多...
【大厂AI课学习笔记】【1.6 人工智能基础知识】（1）人工智能、机器学习、深度学习之间的关系

【大厂AI课学习笔记】【1.6 人工智能基础知识】（1）人工智能、机器学习、深度学习之间的关系

6.1 人工智能、机器学习与深度学习的关系 必须要掌握的内容&#xff1a; 如上图&#xff1a;人工智能>机器学习>深度学习。 机器学习是人工智能的一个分支&#xff0c;该领域的主要研究对象是人工智能&#xff0c;特别是如何在经验学习中改进具体算法的性能。 深度学习…
阅读更多...
TCP 传输控制协议——详细

TCP 传输控制协议——详细

目录 1 TCP 1.1 TCP 最主要的特点 1.2 TCP 的连接 TCP 连接&#xff0c;IP 地址&#xff0c;套接字 1.3 可靠传输的工作原理 1.3.1 停止等待协议 &#xff08;1&#xff09;无差错情况 &#xff08;2&#xff09;出现差错 &#xff08;3&#xff09;确认丢失和确认迟到…
阅读更多...
【linux系统体验】-archlinux折腾日记

【linux系统体验】-archlinux折腾日记

archlinux 一、系统安装二、系统配置及美化2.1 中文输入法2.2 安装virtualbox增强工具2.3 终端美化2.4 桌面面板美化 三、问题总结3.1 一、系统安装 安装步骤人们已经总结了很多很全: Arch Linux图文安装教程 大体步骤&#xff1a; 磁盘分区安装 Linux内核配置系统&#xff…
阅读更多...
redis双写一致

redis双写一致

redis双写一致&#xff0c;指的是redis缓存与mysql数据同步 双写一致常见方案有很多&#xff1a; 同步双写&#xff1a;更新完mysql后立即同时更新redis mq同步&#xff1a;程序在更新完mysql后&#xff0c;投递消息到中间键mq&#xff0c;一个程序监听mq&#xff0c;获得消…
阅读更多...
基于Springboot的足球社区管理系统（有报告）。Javaee项目，springboot项目。

基于Springboot的足球社区管理系统（有报告）。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的足球社区管理系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构…
阅读更多...
电力负荷预测 | Matlab实现基于LSTM长短期记忆神经网络的电力负荷预测模型（结合时间序列）

电力负荷预测 | Matlab实现基于LSTM长短期记忆神经网络的电力负荷预测模型（结合时间序列）

文章目录 效果一览文章概述源码设计参考资料效果一览 文章概述 电力负荷预测 | Matlab实现基于LSTM长短期记忆神经网络的电力负荷预测模型（结合时间序列） 所谓预测，就是指通过对事物进行分析及研究，并运用合理的方法探索事物的发展变化规律，对其未来发展做出预先估计和判断…
阅读更多...
【漏洞复现】狮子鱼CMS某SQL注入漏洞01

【漏洞复现】狮子鱼CMS某SQL注入漏洞01

Nx01 产品简介 狮子鱼CMS&#xff08;Content Management System&#xff09;是一种网站管理系统&#xff0c;它旨在帮助用户更轻松地创建和管理网站。该系统拥有用户友好的界面和丰富的功能&#xff0c;包括页面管理、博客、新闻、产品展示等。通过简单直观的管理界面&#xf…
阅读更多...
Ubuntu22.04 gnome-builder gnome C 应用程序习练笔记(三)

Ubuntu22.04 gnome-builder gnome C 应用程序习练笔记(三)

八、ui窗体创建要点 .h文件定义(popwindowf.h)&#xff0c; TEST_TYPE_WINDOW宏是要创建的窗口样式。 #pragma once #include <gtk/gtk.h> G_BEGIN_DECLS #define TEST_TYPE_WINDOW (test_window_get_type()) G_DECLARE_FINAL_TYPE (TestWindow, test_window, TEST, WI…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发