c++初阶-----STL---list

作者前言

🎂 ✨✨✨✨✨✨🍧🍧🍧🍧🍧🍧🍧🎂
​🎂 作者介绍: 🎂🎂
🎂 🎉🎉🎉🎉🎉🎉🎉 🎂
🎂作者id:老秦包你会, 🎂
简单介绍:🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂
喜欢学习C语言、C++和python等编程语言,是一位爱分享的博主,有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂
🎂个人主页::小小页面🎂
🎂gitee页面:秦大大🎂
🎂🎂🎂🎂🎂🎂🎂🎂
🎂 一个爱分享的小博主 欢迎小可爱们前来借鉴🎂


list

  • **作者前言**
  • list的介绍
  • list的简单使用
    • reverse
    • merge
    • unique
    • splice
  • list的模拟实现
    • 迭代器的模拟
      • **普通的迭代器**
      • const迭代器
      • 反向迭代器
      • 重载->

list的介绍

list页面
list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。
2. list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向
其前一个元素和后一个元素。
3. list与forward_list非常相似:最主要的不同在于forward_list是单链表,只能朝前迭代,已让其更简单高
效。
4. 与其他的序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率
更好。
5. 与其他序列式容器相比,list和forward_list最大的缺陷是不支持任意位置的随机访问,比如:要访问list
的第6个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间
开销;list还需要一些额外的空间,以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这
可能是一个重要的因素)
在这里插入图片描述

#include<iostream>
#include<vector>
#include<list>
using namespace std;
int main()
{list<int> lt;lt.push_back(10);lt.push_back(11);lt.push_back(12);lt.push_back(13);lt.push_back(14);lt.push_back(15);list<int>::iterator it = lt.begin();while (it != lt.end()){cout << *it;it++;}cout << endl;for (auto& e:lt){cout << e;}return  0;
}

前面我们知道,string和vector的遍历方式有迭代器,下标和 地址
但是在list中没有下标,通过地址去访问困难,只能通过迭代器去访问,这个时候就会很方便,不用再和之前的C语言那样,获取到对应的地址进行方位,我们只需获取到对应的迭代器就可以快速,迭代器的优势也慢慢的体现出来了

list的简单使用

经过前面的string和vector我们可以使用一些简单 的成员函数,begin、end等相关的成员函数,我这里不详细的去介绍了,下面我简单的介绍一些不经常讲过的,

reverse

需要注意的是这个名称,在string和vector中是reserve()成员函数,是一个进行空间扩大的函数,这两者是不一样的,而reverse是list中特有的成员函数
进行翻转,把元素从头到尾进行翻转

	list<int> lt;lt.push_back(10);lt.push_back(11);lt.push_back(12);lt.push_back(13);lt.push_back(14);lt.push_back(15);list<int>::iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";it++;}cout << endl;lt.reverse();for (auto& e:lt){cout << e << " ";}

在这里插入图片描述

merge

合并列表
该算法将一个有序list容器加入另一个有序list容器中,且两个list容器必须都为逆序或顺序

unique

去重
前提条件就是: 相同的元素要站在一堆,最好的方式就是有序

splice

连接
把一个list容器的一些内容或者整个连接到另外一个list容器上面去,右边的list容器就变空了
在这里插入图片描述

list的模拟实现

前面我们实现过单链表和双向链表,这次我们模拟实现list和前面的类似
节点的类以及list的类,有两个
我们可以写一个命名空间里面进行
下面我们以这个图为例子
在这里插入图片描述
所以我们要创建一个节点类, list里面是一个链表,
节点类:

	//节点类template<class T>struct ListNode{public:ListNode<T>* left;ListNode<T>* rigth;T val;ListNode(const T& num = T()):left(nullptr),rigth(nullptr),val(num){}bool operator==(const ListNode<T> n){return this == &n;}};

跟我们刚开始 的C语言的节点写法一样,

迭代器的模拟

普通的迭代器

//迭代器template<class T>class _list_iterator{public:typedef ListNode<T> Node;typedef _list_iterator<T> Self;Node* node;_list_iterator(ListNode<T>* n)//需要注意的是这里尽量不要用引用:node(n){}_list_iterator(const Self& n):node(n.node){}Self& operator++()//前置++{node = node->rigth;return *this;}Self operator++(int)//后置++{Self newnode(*this);node = node->rigth;return newnode;}Self& operator--()//前置--{node = node->left;return *this;}Self operator--(int)//后置--{Self newnode(*this);node = node->left;return newnode;}T& operator*(){return this->node->val;}bool operator!=(const Self& n){return !(*this == n);}bool operator==(const Self& n){return node == n.node;}};

在迭代器类的那里,我们不能使用地址来typedef,因为地址不连续,所以需要写一个迭代器类,迭代器类里面要进行运算符重载,必须重载* 、 != 、前后置++和–, 这里的迭代器只是一个普通的迭代器,如果要实现一个const迭代器就需要另外写法

const迭代器

我们明白const迭代器防止的是指向的内容不能修改不是迭代器本身不能修改,所以不能在普通迭代器使用const关键字修饰

// const 迭代器template<typename T>class _list_const_iterator{public:typedef ListNode<T> Node;typedef _list_const_iterator const_self;typedef const_self  Self;Node const* node;//这里可以不添加const修饰_list_const_iterator( const Node* n):node(n){}Self& operator++() //前置++{node = node->rigth;return *this;}Self operator++(int) //后置++{Self newnode(*this);node = node->rigth;return newnode;}Self& operator--()//前置--{node = node->left;return *this;}Self operator--(int)//后置--{Self newnode(*this);node = node->left;return newnode;}const T& operator*() const{return this->node->val;}bool operator!=(const Self& n) const{return !(*this == n);}bool operator==(const Self& n) const{return node == n.node;}};

这是和普通类相似很多的写法,唯一不同的就是operator那里返回值不同,但是这种写法冗余了,图中的很多函数都加了const修饰this,让起不能修改this的成员,需要注意的就是使用const修饰this, 要知道this的成员是否要修改,根据情况来定,
我们要清楚: const迭代器有两个作用一个是迭代器本身可以修改,一个是其指向的内容不能被修改,如果简单理解为 const iterator就是const迭代器,是错误的,因为这样写只能说明 该值不能被修改,违背了const迭代器的第一个作用.
方法2:
在普通迭代器上再增加一个类型,用来控制operator
的返回值

template<class T, class Ref>class _list_iterator{public:typedef ListNode<T> Node;typedef _list_iterator<T,Ref> Self;Node* node;_list_iterator(ListNode<T>* n):node(n){}_list_iterator(const Self& n):node(n.node){}Self& operator++()//前置++{node = node->rigth;return *this;}Self operator++(int)//后置++{Self newnode(*this);node = node->rigth;return newnode;}Self& operator--()//前置--{node = node->left;return *this;}Self operator--(int)//后置--{Self newnode(*this);node = node->left;return newnode;}Ref& operator*(){return this->node->val;}bool operator!=(const Self& n){return !(*this == n);}bool operator==(const Self& n){return node == n.node;}};

反向迭代器

这里我使用的方法是适配器的方法,套一个外壳,只要传入不同的迭代器就可以实现对应的++、–等功能

// 反向迭代器, 使用适配器的方法template<class T, class Ref,class Compart = _list_iterator<T, Ref>>class _list_reverse__iterator{public:typedef _list_reverse__iterator<T,Ref> Self;_list_reverse__iterator(Compart cp):it(cp){}Self& operator++(){it--;return *this;}/*	Self& operator++()const{it--;return *this;}*/Self operator++(int){Compart ne = it;it--;return ne;}/*	Self operator++(int)const{Compart ne = it;it--;return ne;}*/Self& operator--(){it++;return it;}/*	Self& operator--()const{it++;return it;}*/Self operator--(int){Compart ne = *this;it++;return ne;}/*Self operator--(int)const{Compart ne = *this;it++;return ne;}*/bool operator!=(const Self& iter){return it != iter.it;}/*bool operator!=(const Self& iter)const{return it != iter.it;}*/bool operator==(const Self& iter){return it == iter.it;}/*	bool operator==(const Self& iter)const{return it == iter.it;}*/Ref& operator*(){return *it;}/*Ref& operator*()const{return *it;}*/private:Compart it;};

这里重载了const修饰的this指针的运算符,可以不看,这里的原理就是, 只要传入不同的迭代器,然后进行对应的操作, 所以说,反向迭代器的实现,就可以解决const反向迭代器的实现了,可以说一举多得

重载->

这里有一个好玩的点

#include<iostream>
#include<list>
using namespace std;
namespace bit
{class AA{public:int a = 10;int b = 20;};template<class T>class BB{public:T* operator->(){return &(this->t);}private:T t;};
}
int main()
{bit::BB<bit::AA> t;cout << t->a << endl;// t.operator->()->acout << t->b << endl;//t.operator->()->breturn 0;
}

需要注意的是这里这里c++会省略一个**->**,增加了可读性,这里本来有两个->,省略了一个,由此可见,我们如果要重载一个->就要注意了

list类:

//迭代器template<class T>class _list_iterator{public:typedef ListNode<T> Node;typedef _list_iterator<T> Self;Node* node;_list_iterator(ListNode<T>*& n):node(n){}_list_iterator(const Self& n):node(n.node){}Self& operator++()//前置++{node = node->rigth;return *this;}Self operator++(int)//后置++{Self newnode(*this);node = node->rigth;return newnode;}Self& operator--()//前置--{node = node->left;return *this;}Self operator--(int)//后置--{Self newnode(*this);node = node->left;return newnode;}T& operator*(){return this->node->val;}bool operator!=(const Self& n){return !(*this == n);}bool operator==(const Self& n){return node == n.node;}};//记得我们模拟实现的list要有哨兵位template<class T>class list{public:typedef ListNode<T> Node;typedef _list_iterator<T> iterator;list()//初始化,创建哨兵位{_head = new Node();_head->left = _head;_head->rigth = _head;}~list(){clear();delete this->_head;cout << "析构完毕" << endl;}list(list<T>& n){//浅拷贝(容易野指针)//this->_head = n._head;_head = new Node();_head->left = _head;_head->rigth = _head;for ( const auto& e : n){push_back(e);}}void swap(list<T>& n){Node* swapelem = this->_head;this->_head = n._head;n._head = swapelem;}list<T>& operator=(list<T> n){////方法1//if (this != &n)//{//	clear();//	for (const auto& e : n)//	{//		push_back(e);//	}//}//方法2swap(n);return *this;}void clear(){iterator it = begin();while (it != end()){pop_front();it = begin();}}void push_back(const T& num){//方法1/*Node* nextnode = new Node(num);_head->left->rigth = nextnode;_head->left = nextnode;nextnode->rigth = _head;*///方法二inset(end(), num);}iterator begin(){iterator it(_head->rigth);return it;// return _head->rigth 隐式类型转换}iterator end(){//隐式类型转换return _head;}iterator inset(iterator pos, const T& num){Node* cur = pos.node;//记得当前位置Node* prev = cur->left;//上一个Node* newnode = new Node(num);newnode->rigth = cur;cur->left = newnode;newnode->left = prev;prev->rigth = newnode;return newnode;}void push_front(const T& num){inset(begin(), num);}iterator erase(iterator pos){assert(pos != end());Node* prev = (pos.node)->left;Node* next = (pos.node)->rigth;prev->rigth = next;next->left = prev;delete pos.node;return next;}void pop_back(){erase(--end());}void pop_front(){erase(begin());}private:Node* _head;};

我们需要注意的就是迭代器和list 的初始化,
总代码代码如下:

#define _CRT_SECURE_NO_WARNINGS
#include<istream>
#include<list>
#include<iostream>
#include<assert.h>
using namespace std;
namespace bit
{//节点类template<class T>struct ListNode{public:ListNode<T>* left;ListNode<T>* rigth;T val;ListNode(const T& num = T()):left(nullptr), rigth(nullptr), val(num){}bool operator==(const ListNode<T> n){return this == &n;}};//迭代器template<class T, class Ref>class _list_iterator{public:typedef ListNode<T> Node;typedef _list_iterator<T, Ref> Self;Node* node;_list_iterator(ListNode<T>* n):node(n){}_list_iterator(const Self& n):node(n.node){}Self& operator++()//前置++{node = node->rigth;return *this;}Self operator++(int)//后置++{Self newnode(*this);node = node->rigth;return newnode;}Self& operator--()//前置--{node = node->left;return *this;}Self operator--(int)//后置--{Self newnode(*this);node = node->left;return newnode;}Ref& operator*(){return this->node->val;}bool operator!=(const Self& n){return !(*this == n);}bool operator==(const Self& n){return node == n.node;}};// 反向迭代器, 使用适配器的方法template<class T, class Ref,class Compart = _list_iterator<T, Ref>>class _list_reverse__iterator{public:typedef _list_reverse__iterator<T,Ref> Self;_list_reverse__iterator(Compart cp):it(cp){}Self& operator++(){it--;return *this;}/*	Self& operator++()const{it--;return *this;}*/Self operator++(int){Compart ne = it;it--;return ne;}/*	Self operator++(int)const{Compart ne = it;it--;return ne;}*/Self& operator--(){it++;return it;}/*	Self& operator--()const{it++;return it;}*/Self operator--(int){Compart ne = *this;it++;return ne;}/*Self operator--(int)const{Compart ne = *this;it++;return ne;}*/bool operator!=(const Self& iter){return it != iter.it;}/*bool operator!=(const Self& iter)const{return it != iter.it;}*/bool operator==(const Self& iter){return it == iter.it;}/*	bool operator==(const Self& iter)const{return it == iter.it;}*/Ref& operator*(){return *it;}/*Ref& operator*()const{return *it;}*/private:Compart it;};// const 迭代器template<typename T>class _list_const_iterator{public:typedef ListNode<T> Node;typedef _list_const_iterator const_self;typedef const_self  Self;Node const* node;_list_const_iterator(const Node*& n):node(n){}Self& operator++() //前置++{node = node->rigth;return *this;}Self operator++(int) //后置++{Self newnode(*this);node = node->rigth;return newnode;}Self& operator--()//前置--{node = node->left;return *this;}Self operator--(int)//后置--{Self newnode(*this);node = node->left;return newnode;}const T& operator*() const{return this->node->val;}bool operator!=(const Self& n) const{return !(*this == n);}bool operator==(const Self& n) const{return node == n.node;}};//记得我们模拟实现的list要有哨兵位template<class T>class list{public:typedef ListNode<T> Node;typedef _list_iterator<T, T> iterator;typedef _list_iterator<T, const T> const_iterator;typedef _list_reverse__iterator<T, T,iterator> reverse_iterator;typedef _list_reverse__iterator<T, const T,const_iterator> const_reverse_iterator;list()//初始化,创建哨兵位{_head = new Node();_head->left = _head;_head->rigth = _head;}~list(){clear();delete this->_head;cout << "析构完毕" << endl;}list(const list<T>& n){//浅拷贝(容易野指针)//this->_head = n._head;_head = new Node();_head->left = _head;_head->rigth = _head;for (const auto& e : n){push_back(e);}}void swap(list<T>& n){Node* swapelem = this->_head;this->_head = n._head;n._head = swapelem;}list<T>& operator=(list<T> n){////方法1//if (this != &n)//{//	clear();//	for (const auto& e : n)//	{//		push_back(e);//	}//}//方法2swap(n);return *this;}void clear(){iterator it = begin();while (it != end()){pop_front();it = begin();}}void push_back(const T& num){//方法1/*Node* nextnode = new Node(num);_head->left->rigth = nextnode;_head->left = nextnode;nextnode->rigth = _head;*///方法二inset(end(), num);}iterator begin(){iterator it(_head->rigth);return it;// return _head->rigth 隐式类型转换}const_iterator begin() const{const_iterator it(_head->rigth);return it;}reverse_iterator rbegin(){return --end();}const_reverse_iterator rbegin() const{return --end();}iterator end(){//隐式类型转换return _head;}const_iterator end() const{const_iterator it(_head);return it;}reverse_iterator rend(){//隐式类型转换return end();}const_reverse_iterator rend()const{//隐式类型转换return end();}iterator inset(iterator pos, const T& num){Node* cur = pos.node;//记得当前位置Node* prev = cur->left;//上一个Node* newnode = new Node(num);newnode->rigth = cur;cur->left = newnode;newnode->left = prev;prev->rigth = newnode;return newnode;}void push_front(const T& num){inset(begin(), num);}iterator erase(iterator pos){assert(pos != end());Node* prev = (pos.node)->left;Node* next = (pos.node)->rigth;prev->rigth = next;next->left = prev;delete pos.node;return next;}void pop_back(){erase(--end());}void pop_front(){erase(begin());}private:Node* _head;};}
int main()
{bit::list<int> lt1;lt1.push_back(222);bit::list<int> lt;lt = lt1;lt.push_front(10);lt.push_front(12);lt.push_front(13);lt.push_front(14);lt.push_front(15);lt.push_front(16);lt.pop_back();lt.pop_front();//bit::list<int>::iterator it = lt.begin();//lt.erase(it);//lt.clear();//it = lt.begin();//while (it != lt.end())//{//	cout << *it << endl;//	it++;//}//it--;//cout << *it-- << endl;const bit::list<int> lt2(lt);bit::list<int>::const_reverse_iterator const_it = lt2.rbegin();while (const_it != lt2.rend()){cout << *const_it << endl;const_it++;}//for (auto& e : lt2)//{//	cout << e << endl;//}//for (const auto& e : lt)//{//	cout << e << endl;//}return 0;
}

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

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

相关文章

Datawhale AI夏令营第四期 魔搭-AIGC方向 task01笔记

目录 赛题内容 可图Kolors-LoRA风格故事挑战赛 baseline要点讲解(请配合Datawhale速通教程食用) Step1 设置算例及比赛账号的报名和授权 Step2 进行赛事报名并创建PAI实例 Step3 执行baseline Step4 进行赛题提交 微调结果上传魔搭 lora 调参参数介绍及 SD 的基础知识点…

ICETEK-DM6437-AICOM——CPU定时器及直流电机控制中断控制

一、设计目的&#xff1a; 1.1 CPU定时器程序设计&#xff1b; 1.2 2直流电机程序设计&#xff1b; 1.3 外中断。 二、设计原理&#xff1a; 2.1 定时器的控制&#xff1a; 在DM6437&#xff08;是一种数字信号处理器&#xff0c;DSP&#xff09;上使用其内部定时器和中断来…

JESD204B/C协议学习笔记

JESD204B基础概念 204B包含传输层&#xff0c;链路层&#xff0c;物理层。 应用层是对 JESD204B 进行配置的接口&#xff0c;在标准协议中是不含此层&#xff0c;只是为了便于理解&#xff0c;添加的一个层。 协议层指工程中生成的IP核JESD204B&#xff0c;负责处理输入的用户…

Java网络编程——简单的 API 调用

Get请求 - 无参数 上一章我们学习了网络的基本概念&#xff0c;我们知道 URL 能输入到浏览器地址栏中被打开&#xff0c; 那么能不能在程序中发送请求&#xff0c;获取结果呢&#xff1f; 例如“中国科学技术大学”的网站&#xff08;https://www.ustc.edu.cn/&#xff09;&a…

探索设计模式:观察者模式

探索设计模式&#xff1a;观察者模式 &#x1f9d0;观察者模式简介:gem:核心概念:rainbow:观察者模式的优点:truck:实现步骤1. 定义主题接口2. 实现观察者接口3. 具体主题实现4. 具体观察者实现5. 调用 :triangular_flag_on_post:总结 在实际开发过程中&#xff0c;设计模式的作…

【Hot100】LeetCode—124. 二叉树中的最大路径和

1- 思路 使用递归 dfs 实现① 递归思路&#xff1a;每次递归返回值为 &#xff0c; root.valMath.max(left,right) 从 左右孩子中挑选一个大的。② 递归公式&#xff1a;定义 sum&#xff0c;sum root.val left right 2- 实现 ⭐124. 二叉树中的最大路径和——题解思路 cl…

【矩阵对角线求和】求一个3*3矩阵对角线元素之和

求一个3*3矩阵对角线元素之和&#xff0c;使用C语言实现 具体代码&#xff1a; #include<stdio.h>int main(){float a[3][3],sum0;printf("请输入3x3矩阵的元素&#xff08;按行输入&#xff09;&#xff1a;\n");for(int i0;i<3;i){for(int j0;j<3;j)…

Java、PHP、Node 操作 MySQL 数据库常用方法

一、Java 操作 MySQL 数据库 1、Java 连接 MySQL 数据库 1. 使用 JDBC 驱动程序连接 使用这种方式&#xff0c;首先需要导入 MySQL 的 JDBC 驱动程序依赖&#xff0c;然后通过 Class.forName() 方法加载驱动程序类。其创建连接的过程相对直接&#xff0c;只需提供准确的数据库…

Tech Talk: SSD架构与功能模块详解

在之前的系列文章中&#xff0c;我们介绍了固态硬盘的系列知识&#xff0c;包括闪存的介质、原理&#xff0c;以及作为SSD大脑的控制器设计&#xff0c;本文将详细介绍SSD架构以及功能模块。 SSD架构简介 ◎SSD架构示意图 如上图所示&#xff0c;典型的SSD架构包括主机接口、SS…

点亮童梦思考之光,神秘伙伴震撼登场!

本文由 ChatMoney团队出品 介绍说明 咱们来聊聊“十万个为什么”机器人&#xff0c;这对小朋友来说&#xff0c;好处可多了去啦&#xff01; 小朋友们天生好奇&#xff0c;满脑子都是问号。 这个机器人就像个啥都懂的知识达人&#xff0c;不管他们问啥&#xff0c;都能给出答…

JVM知识总结(类加载器)

文章收录在网站&#xff1a;http://hardyfish.top/ 文章收录在网站&#xff1a;http://hardyfish.top/ 文章收录在网站&#xff1a;http://hardyfish.top/ 文章收录在网站&#xff1a;http://hardyfish.top/ 类加载器 Bootstrap引导类加载器 引导类加载器也被称为启动类加载…

麦田物语第二十天

系列文章目录 麦田物语第二十天 文章目录 系列文章目录一、构建地图信息系统二、生成地图数据 一、构建地图信息系统 我们上一节课已经做好了鼠标的显示&#xff0c;这节课需要构建地图的一些信息&#xff0c;例如&#xff1a;可挖坑&#xff0c;可丢弃物品等地区。我们点击地…

c语言学习,isdigit()函数分析

1&#xff1a;isdigit() 函数说明&#xff1a; 检查参数c&#xff0c;是否为0到9阿拉伯数字 2&#xff1a;函数原型&#xff1a; int isdigit(int c) 3&#xff1a;函数参数&#xff1a; 参数c&#xff0c;为检测整数 4&#xff1a;返回值&#xff1a; 参数c是阿拉伯码字符&…

【机器学习第8章——集成学习】

机器学习第8章——集成学习 8.集成学习8.1个体与集成弱分类器之间的关系组合时&#xff0c;如何选择学习器怎么组合弱分类器boosting和Bagging 8.2 BoostingAdaBoost算法步骤训练过程 8.3 Bagging与随机森林随机采样(bootstrap)弱学习器结合策略方差与偏差算法流程随机森林 8.4…

中职云计算实训室

一、实训室建设背景 随着信息技术的飞速发展&#xff0c;云计算已成为推动数字化转型、促进经济社会发展的重要力量。《中华人民共和国国民经济和社会发展第十四个五年规划和2035年远景目标纲要》明确提出&#xff0c;要加快数字化发展&#xff0c;建设数字中国。云计算作为数…

NLP——Transfromer 架构详解

Transformer总体架构图 输入部分&#xff1a;源文本嵌入层及其位置编码器、目标文本嵌入层及其位置编码器 编码器部分 由N个编码器层堆叠而成 每个编码器层由两个子层连接结构组成 第一个子层连接结构包括一个多头自注意力子层和规范化层以及一个残差连接 第二个子层连接结构包…

基于Java中的SSM框架实现远程同步课堂系统项目【项目源码+论文说明】计算机毕业设计

基于Java中的SSM框架实现远程同步课堂系统演示 远程同步课堂系统设计与实现 摘要&#xff1a;在这样一个网络数据大爆炸的时代&#xff0c;人们获取知识、获取信息的通道非常的多元化&#xff0c;通过网络来实现数据信息的获取成为了现在非常常见的一种方式&#xff0c;而通过…

MindSearch:用于增强网络搜索效率的开源人工智能

Web 信息查找与集成是搜索、检索、提取或集成 Web 资源以满足特定需求的活动&#xff0c;是实际生活中几乎所有领域中每个决策和解决问题的实体都必须执行的操作。 大型语言模型 (LLM) 与搜索引擎的集成重新定义了我们在网络上查找和使用信息的方式。因此&#xff0c;LLM 能够…

leetcode递归(203. 移除链表元素)

前言 经过前期的基础训练以及部分实战练习&#xff0c;粗略掌握了各种题型的解题思路。现阶段开始专项练习。 描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a;…

将元组类型的日期时间转换为字符串格式time.asctime([t])

【小白从小学Python、C、Java】 【考研初试复试毕业设计】 【Python基础AI数据分析】 将元组类型的日期时间转换为 字符串格式 time.asctime([t]) [太阳]选择题 根据给定的Python代码&#xff0c;哪个选项是错误的&#xff1f; import time time_tuple (1993, 6, 30, 21, 49…