C++基础10:STL容器list

最新推荐文章于 2024-01-28 14:33:46 发布
最新推荐文章于 2024-01-28 14:33:46 发布
阅读量130 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42278523/article/details/106213792
版权

1.基础操作

1.1 遍历+正反顺序打印

(1)C++11遍历的方法

for(auto n:l){ // （1）C++11遍历的方法
        cout << n << " ";
    }
    cout << endl;

（2）不支持下标访问

for(int i=0;i<l.size();++i){
        // cout << l[i] << " "; // （2）不支持下标访问
    }

(3)正序打印

list<int>::iterator it = l.begin();  //(3)正序打印
    while(it != l.end()){
       cout << *it << " ";
       ++it;
    }
    cout << endl;

(4)逆序打印

list<int>::reverse_iterator rit = l.rbegin();//(4)逆序打印
    while(rit != l.rend()){
       cout << *rit << " ";
       ++rit;
    }
    cout << endl;
  • 完整案例
#include <iostream>
#include <list>
#include <vector>

using namespace std;
void Travesal(const list<int>& l){
    list<int>::const_iterator it = l.cbegin();//cbegin() C++11
    while(it != l.cend()){ //cend() C++11
       cout << *it << " ";
       ++it;
    }
    cout << endl;
}
void TravesalReverse(const list<int>& l){
    list<int>::const_reverse_iterator rit = l.crbegin();
    while(rit != l.crend()){
       cout << *rit << " ";
       ++rit;
    }
    cout << endl;
}
int main()
{
     list<int> l = {1,2,3,4,5};// C++11

    for(auto n:l){ // （1）C++11遍历的方法
        cout << n << " ";
    }
    cout << endl;

    for(int i=0;i<l.size();++i){
        // cout << l[i] << " "; // （2）不支持下标访问
    }

    list<int>::iterator it = l.begin();  //(3)正序打印
    while(it != l.end()){
       cout << *it << " ";
       ++it;
    }
    cout << endl;

    list<int>::reverse_iterator rit = l.rbegin();//(4)逆序打印
    while(rit != l.rend()){
       cout << *rit << " ";
       ++rit;
    }
    cout << endl;
    Travesal(l); 
    TravesalReverse(l);

}

1.2 添加，删除

(1)尾添加

 l.push_back(6);

(2)尾删除

l.pop_back();

(3) 首添加

l.push_front(-2);

(4) 首删除

l.pop_front();
  • 完整案例
#include <iostream>
#include <list>
#include <vector>

using namespace std;
void Travesal(const list<int>& l){
    list<int>::const_iterator it = l.cbegin();//cbegin() C++11
    while(it != l.cend()){ //cend() C++11
       cout << *it << " ";
       ++it;
    }
    cout << endl;
}
void TravesalReverse(const list<int>& l){
    list<int>::const_reverse_iterator rit = l.crbegin();
    while(rit != l.crend()){
       cout << *rit << " ";
       ++rit;
    }
    cout << endl;
}
int main()
{
     list<int> l = {1,2,3,4,5};// C++11
     Travesal(l);

     // 尾添加
    l.push_back(6);
    l.push_back(7);
    l.push_back(8);
    Travesal(l);
    // 尾删除
    l.pop_back();
    l.pop_back();
    l.pop_back();
    Travesal(l);

    // 首添加
    l.push_front(-2);
    l.push_front(-1);
    l.push_front(0);
    Travesal(l);
    // 首删除
    l.pop_front();
    l.pop_front();
    l.pop_front();
    Travesal(l);

}

1.3 任意位置添加、删除

（1）insert（）：list的迭代器不能做算术运算，没有算术运算符重载，但是可以自增自减（左闭右开的区间）

// 插入
    auto it = l.begin();
    ++it;
    // it = it + 1; // （1）list的迭代器不能做算术运算，没有算术运算符重载，但是可以自增自减
    l.insert(it,100); //表示在begin()+1的内存插入100，内存发生改变；此时it指针指向100的后面；（左闭又开的区间）

(2) erase():想要删除100,必须指向100的内存；必须先自减

 // 删除
    --it;
    l.erase(it);  //(2)想要删除100,必须指向100的内存；必须先自减
    Travesal(l);

(3) 批量插入: 插入多个相同的元素，此时指向index=5的后面；

// 批量插入
    it = l.begin();
    ++it;
    l.insert(it,5,100); //插入多个相同的元素，此时指向index=5的后面；
    Travesal(l);

(4) 批量删除

 list<int>::iterator first = l.begin();
    ++first;
    l.erase(first,it);// 删除的部分[1,6)
    Travesal(l);

(5) 插入数组

   int arr[] = {11,12,13,14};
    l.insert(it,arr,arr+4);
    Travesal(l);

(6) 插入向量

vector<int> vec = {21,22,23,24};
l.insert(l.end(),vec.begin(),vec.end());
Travesal(l);

(7) 随机访问，只能遍历
next() ：C++11,begin（）往后数4个元素；ndex = 4;
prev() ： 往前数三个元素,index=end()-3,即倒数第三个数，首尾的差异

auto it = next(l.begin(),4); //C++11,begin（）往后数4个元素；ndex = 4;
//prev()    往前数三个元素,index=end()-3,即倒数第三个数，首尾的差异
*it = 10000;
Travesal(l);
  • 完整案例
#include <iostream>
#include <list>
#include <vector>

using namespace std;
void Travesal(const list<int>& l){
    list<int>::const_iterator it = l.cbegin();//cbegin() C++11
    while(it != l.cend()){ //cend() C++11
       cout << *it << " ";
       ++it;
    }
    cout << endl;
}
void TravesalReverse(const list<int>& l){
    list<int>::const_reverse_iterator rit = l.crbegin();
    while(rit != l.crend()){
       cout << *rit << " ";
       ++rit;
    }
    cout << endl;
}
int main()
{
     list<int> l = {1,2,3,4,5};// C++11
     Travesal(l);

  // 插入
    auto it = l.begin();
    ++it;
    // it = it + 1; // （1）list的迭代器不能做算术运算，没有算术运算符重载，但是可以自增自减
    l.insert(it,100); //表示在begin()+1的内存插入100，内存发生改变；此时it指针指向100的后面；（左闭又开的区间）
    Travesal(l);

    // 删除
    --it;
    l.erase(it);  //(2)想要删除100,必须指向100的内存；必须先自减
    Travesal(l);


    // 批量插入
    it = l.begin();
    ++it;
    l.insert(it,5,100); //插入多个相同的元素，此时指向index=5的后面；
    Travesal(l);

    // 批量删除
    list<int>::iterator first = l.begin();
    ++first;
    l.erase(first,it);// 删除的部分[1,6)
    Travesal(l);

    // 插入数组
    int arr[] = {11,12,13,14};
    l.insert(it,arr,arr+4);
    Travesal(l);

    // 插入向量
    vector<int> vec = {21,22,23,24};
    l.insert(l.end(),vec.begin(),vec.end());
    Travesal(l);
	
	auto it = next(l.begin(),4); //C++11,begin（）往后数4个元素；ndex = 4;
	//prev()    往前数三个元素,index=end()-3,即倒数第三个数，首尾的差异
	*it = 10000;
	Travesal(l);

}

1.4 list特有的函数

(1) reverse: 逆序

  l.reverse();
  Travesal(l);

(2) sort:排序

  l.sort();
  Travesal(l);

(3) merge():按大小顺序插入

  list<int> l2={3,6,9,10,13};
  l.merge(l2);

(4) remove(): 删除值

  l.remove(1);
  Travesal(l);

(5) 删除某个条件的值
a.普通函数

  bool condition(int n){
    return n/10 == 1;
}
  l.remove_if(condition);（1）普通函数

b. 仿函数

 Condition cond; 
    l.remove_if(cond); //（2）仿函数
     l.remove_if(Condition());

c. lamabda表达式

  l.remove_if([](int n){return n/10==1;}); //（3）lamabda表达式
  • 完整案例
#include <iostream>
#include <list>
#include <vector>

using namespace std;
void Travesal(const list<int>& l){
    list<int>::const_iterator it = l.cbegin();//cbegin() C++11
    while(it != l.cend()){ //cend() C++11
       cout << *it << " ";
       ++it;
    }
    cout << endl;
}
void TravesalReverse(const list<int>& l){
    list<int>::const_reverse_iterator rit = l.crbegin();
    while(rit != l.crend()){
       cout << *rit << " ";
       ++rit;
    }
    cout << endl;
}

bool condition(int n){
    return n/10 == 1;
}

int main()
{
     list<int> l = {1,2,3,4,5};// C++11
     Travesal(l);

  // list特有的成员函数
    // 逆序
    l.reverse();
    Travesal(l);

    // 排序
    l.sort();
    Travesal(l);

    list<int> l2={3,6,9,10,13};

    l.merge(l2);
    Travesal(l);

    // 删除值
    l.remove(1);
    Travesal(l);

    // 删除某个条件的值
    // l.remove_if(condition);（1）普通函数
    // Condition cond; 
    // l.remove_if(cond); //（2）仿函数
    // l.remove_if(Condition());
    l.remove_if([](int n){return n/10==1;}); //（3）amabda表达式
    Travesal(l);

}

(***)2 面试操作(vector.list之间的转化)

2.1 （88）合并两个有序数组

合并两个有序数组

在这里插入图片描述
(1)vector转化为list

list<int> list1(nums1.begin(),nums1.begin()+m);  //(1)vector转化为list

(2)将list2融入到list1

   list1.merge(list2);//(2)将list2融入到list1

(3)list,vector之间的转化

 nums1.assign(list1.begin(),list1.end());      //(3)list,vector之间的转化
  • 完整代码
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {

    list<int> list1(nums1.begin(),nums1.begin()+m);  //(1)vector转化为list
    list<int> list2(nums2.begin(),nums2.begin()+n);
    list1.merge(list2);//(2)将list2融入到list1
    nums1.assign(list1.begin(),list1.end());      //(3)list,vector之间的转化
}
};

3 实现list(miniSTL)

3.1 利用链表简单的构造

(1.1) 节点初始化链表，list初始化链表

 Node(const T& val):val(val),prev(NULL),next(NULL){}  //(1.1)节点初始化链表
 list():head(NULL),tail(NULL),_size(0){}  //(1.2)list初始化链表

(1.2) 实现尾插法：

 void push_back(const T& val){  //（1.2）尾插法插入元素
        ++_size;
        Node* node = new Node(val);
        if(NULL == head){
            head = tail = node;
        }else{
            tail->next = node;
            node->prev = tail;
            tail = node;           
        }
    }

（1.3）重载 [] 运算符；

T& operator[](int index){  //（1.3）重载 [] 运算符；
        // if(index<0 || index >=_size) throw exception(string("invalid index"));
        int count = 0;
        Node* p = head;
        while(NULL != p){
            if(count++ == index) break;
            p = p->next;
        }
        return p->val;
    }

（1.4）c语言的方式进行打印

for(int i=0;i<li.size();++i){
       cout << li[i] << endl;
    }

（1.5）注意list类的大小与嵌套的struct无关；

3.2 迭代器的加入+运算符重载+通用算法

（2.1）加入迭代器

class iterator{
        Node* p;
    public:
        iterator(Node* p):p(p){}
        T& operator*(){return p->val;}
        T* operator->(){return &(p->val);}
        iterator operator++(){
            p=p->next;
            return *this;
        }
        iterator operator++(int){
            iterator tmp(*this);
            p=p->next;
            return tmp;
        }
        iterator operator--(){
            p = p->prev;
            return *this;
        }
        iterator operator--(int){
            iterator tmp(*this);
            p=p->prev;
            return tmp;
        }

        bool operator==(const iterator& it)const{
            return p == it.p;
        }
        bool operator!=(const iterator& it)const{
            return p != it.p;
        }
    };

    iterator begin(){return iterator(head);}
    iterator end(){return iterator(NULL);}
};

（2.2）通用算法(for_each()+ accumulate())

template <typename IT,typename FUNC>
void for_each(IT first,IT last,FUNC func){
    while(first!=last){
        func(*first++);
    }
}

template <typename IT,typename VAL>
VAL accumulate(IT first,IT last,VAL val){
    while(first!=last){
        val+=*first++;
    }
    return val;

}

3.3 list特有算法（首尾（插删））

（3.1）首尾插删

   //尾插法
    void push_back(const T& val){
        ++_size;
        Node* node = new Node(val);  //(1)先创建数据节点
        if(NULL == head){
            head = tail = node;     //(2)头结点判空操作
        }else{                       //(3)先考虑现在：
            tail->next = node;      //(3.1)尾节点的下一个是node;
            node->prev = tail;        //(3.2)node的上一个是尾节点
            tail = node;             //(3.3)refresh
        }
        tail -> next =NULL;
    }
//头插法
    void push_front(const T& val){
        ++_size;
        Node* node = new Node(val);  //(1)先创建数据节点；
        if(NULL == head){            //(2)头结点判空；
            head = tail = node;
        }else{                         //(3)先考虑现在：
            node->next = head;           //(3.1）数据的下一个节点是头结点；
            head->prev = node;            //(3.2）头结点的上一个节点是数据结点；
            head = node;                    //(3.3）refresh；
        }
        tail ->next =NULL;
    }
    
    //尾删法
    void pop_back(){
        --_size;
        Node* prev = tail->prev;        //（1）创建新的尾部结点（即taild的前一个结点）
        if(NULL == prev){               //(2)新的尾节点的判空操作
            head = NULL;
        }else{                           //(3)先考虑现在：
            prev->next = NULL;          //(3.1)新的尾节点的下一个节点是NULL；
        }
        delete tail;                    //(3.2)释放尾节点
        tail = prev;                    //refresh
    }
    
    
    //头删法
    void pop_front(){
        --_size;
        Node* next = head->next;   //（1）创建新的头部节点
        if(NULL == next){          //（2）新的头结点的判空操作；
            tail = NULL;
        }else{                        //(3)先考虑现在：
            next->prev = NULL;        //（3.1）清空原来的头指针   
        }
        delete head;                   //(3.2)删除原来的头指针
        head = next;                      //(3.3) refresh
    }

（3.2）注意：考虑到创建，释放内存 ，必须要有析构函数

  ~list(){
        while(NULL != head){
            Node* next = head->next;  //（1）一直析构头结点；
            delete head;             //（2）清空头结点
            head = next;             //（3）refresh
        }
        head = tail = NULL;          //（4）指针清空
        _size = 0;                    //——size归0
    }

3.4 完整代码

#include <iostream>
// #include <algorithm>
// #include <list>
#include <exception>
using namespace std;

namespace miniSTL{
template<typename T>
class list{
    struct Node{
        T val;
        Node* prev;
        Node* next;
        Node(const T& val):val(val),prev(NULL),next(NULL){}
    };
    Node* head,*tail;
    size_t _size;
public:
    list():head(NULL),tail(NULL),_size(0){}
    // 拷贝构造/赋值运算符重载函数
    ~list(){
        while(NULL != head){
            Node* next = head->next;  //（1）一直析构头结点；
            delete head;             //（2）清空头结点
            head = next;             //（3）refresh
        }
        head = tail = NULL;          //（4）指针清空
        _size = 0;                    //——size归0
    }

    //w尾插法
    void push_back(const T& val){
        ++_size;
        Node* node = new Node(val);  //(1)先创建数据节点
        if(NULL == head){
            head = tail = node;     //(2)头结点判空操作
        }else{                       //(3)先考虑现在：
            tail->next = node;      //(3.1)尾节点的下一个是node;
            node->prev = tail;        //(3.2)node的上一个是尾节点
            tail = node;             //(3.3)refresh
        }
        tail -> next =NULL;
    }
//头插法
    void push_front(const T& val){
        ++_size;
        Node* node = new Node(val);  //(1)先创建数据节点；
        if(NULL == head){            //(2)头结点判空；
            head = tail = node;
        }else{                         //(3)先考虑现在：
            node->next = head;           //(3.1）数据的下一个节点是头结点；
            head->prev = node;            //(3.2）头结点的上一个节点是数据结点；
            head = node;                    //(3.3）refresh；
        }
        tail ->next =NULL;
    }
    
    //尾删法
    void pop_back(){
        --_size;
        Node* prev = tail->prev;        //（1）创建新的尾部结点（即taild的前一个结点）
        if(NULL == prev){               //(2)新的尾节点的判空操作
            head = NULL;
        }else{                           //(3)先考虑现在：
            prev->next = NULL;          //(3.1)新的尾节点的下一个节点是NULL；
        }
        delete tail;                    //(3.2)释放尾节点
        tail = prev;                    //refresh
    }
    
    
    //头删法
    void pop_front(){
        --_size;
        Node* next = head->next;   //（1）创建新的头部节点
        if(NULL == next){          //（2）新的头结点的判空操作；
            tail = NULL;
        }else{                        //(3)先考虑现在：
            next->prev = NULL;        //（3.1）清空原来的头指针   
        }
        delete head;                   //(3.2)删除原来的头指针
        head = next;                      //(3.3) refresh
    }

    size_t size()const{
        return _size;
    }
    T& operator[](int index){
        // if(index<0 || index >=_size) throw exception(string("invalid index"));
        int count = 0;
        Node* p = head;
        while(NULL != p){
            if(count++ == index) break;
            p = p->next;
        }
        return p->val;
    }

    class iterator{
        Node* p;
    public:
        iterator(Node* p):p(p){}
        T& operator*(){return p->val;}
        T* operator->(){return &(p->val);}
        iterator operator++(){
            p=p->next;
            return *this;
        }
        iterator operator++(int){
            iterator tmp(*this);
            p=p->next;
            return tmp;
        }
        iterator operator--(){
            p = p->prev;
            return *this;
        }
        iterator operator--(int){
            iterator tmp(*this);
            p=p->prev;
            return tmp;
        }

        bool operator==(const iterator& it)const{
            return p == it.p;
        }
        bool operator!=(const iterator& it)const{
            return p != it.p;
        }
    };

    iterator begin(){return iterator(head);}
    iterator end(){return iterator(NULL);}
};

template <typename IT,typename FUNC>
void for_each(IT first,IT last,FUNC func){
    while(first!=last){
        func(*first++);
    }
}

template <typename IT,typename VAL>
VAL accumulate(IT first,IT last,VAL val){
    while(first!=last){
        val+=*first++;
    }
    return val;
}

}
using namespace miniSTL;

int main(){
    list<int> li;
    li.push_back(1);
    li.push_back(2);
    li.push_back(3);
    cout << sizeof(li) << endl;

    cout << li.size() << endl;

    for(int i=0;i<li.size();++i){
//        cout << li[i] << endl;
    }

    list<int>::iterator it = li.begin();
    while(it!=li.end()){
        cout << *it++ << endl;
        //++it;
    }
    for(auto n:li){
        cout << n << endl;
    }

    li.push_front(0);
    li.push_front(-1);
    li.push_front(-2);
    li.pop_back();
    li.pop_back();
    li.pop_back();
    li.pop_back();
    li.pop_back();
    li.pop_back();
    li.push_front(-1);
    li.push_front(-2);
    li.pop_front();
    li.pop_front();
    for_each(li.begin(),li.end(),[](int n){cout << n << endl;});

    cout<< accumulate(li.begin(),li.end(),0) << endl;
}
阿华田咯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++初阶 —— list类
NapoleonCoder的博客
11-21 2494
list是可在常数范围内，在任意位置插入和删除的双向迭代序列式容器!
C++知识点23——使用C++标准库（顺序容器list的其他操作）
Master Cui的博客
08-09 300
除了博客https://blog.csdn.net/Master_Cui/article/details/107751785中介绍的操作，list还有一些其他的操作 1.reverse void reverse(); 这个最为简单，作用是反转list 示例 void reversetest() { list<int> l={1,2,3,4,5,6,7}; l.reverse(); for (list<int>::iterator it=l.begin(..
C++ STL list的初始化、添加、遍历、插入、删除、查找、排序、释放
热门推荐
烟花易冷
08-20 16万+
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。 使用list容器之前必须加上STL的list容器的头文件：#include;   list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using nam
STL容器之list的insert
moxiaolin的博客
02-24 5149
list中的insert函数从中间插入元素 没有直接根据第几个元素来插入的函数，不过可以这样来插入第n个元素 list<int>::iterator j = a.begin(); for(i = 0; i < n && j!= a.end(); ++i) ++j; a.insert(j,5,100); 读任意一个元素也可以用同样方法函数，不过可以这样...
C++标准库：STL容器与算法详解
禅与计算机程序设计艺术
01-28 856
1.背景介绍 1. 背景介绍 C++标准库是C++程序设计中不可或缺的一部分，它提供了丰富的数据结构、算法和工具，帮助开发者更高效地编写程序。STL(Standard Template Library)是C++标准库中最重要的一部分，它提供了一系列模板类和模板函数，用于实现各种常用的数据结构和算法。 在本文中，我们将深入探讨STL容器和算法的相关概念、原理、实践和应用。我们将涵盖STL容器的...
C++语言 STL容器list总结
09-01
**C++语言STL容器list总结** STL（Standard Template Library，标准模板库）是C++编程中不可或缺的一部分，它提供了各种容器、迭代器、算法和函数对象等工具。其中，`list`是一种序列容器，它实现了一个双向链表，...
c++ STL容器总结之:vertor与list的应用
09-05
C++中的STL（Standard Template Library，标准模板库）是一个强大的工具集，它极大地提高了C++程序员的生产力。STL的核心组成部分包括...了解并熟练使用STL容器，能够帮助C++程序员编写出更高效、更易于维护的代码。
C++实现STL容器之List
04-08
C++实现STL容器之List
深入解析C++ STL中的常用容器
12-31
STL是C/C++开发中一个非常重要的模板，而其中定义的各种容器也是非常方便我们大家使用。下面，我们就浅谈某些常用的容器。这里我们不涉及容器的基本操作之类，只是要讨论一下各个容器其各自的特点。STL中的常用容器...
c++ STL List查找遍历及各成员函数用法详细介绍
yuzeze的专栏
06-13 2万+
c++ STL List将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.c++ STL List就是一双向链表，可高效地进行插入删除元素。包括构造、方法等。 c++ STL List构造方法...     c++ STL List将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却
STL链表之插入元素（list）
Orz~~Orz
06-28 2126
师 Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 给出一个只有头指针的链表和 n 次操作，每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。 输入 多组输入。每组数据首先输入一个整数n(n∈[1,100])，代表有n次操作。 接下俩的n行，每行有
STL之list学习笔记
云舒编程的博客
07-26 342
参考SGI STL 及 侯捷《STL源码剖析》 stl list 源码下载——带注释 概述 STL的list是一个环状双向链表，链表尾端是一个空节点 list数据结构 list的节点使用prev指向前一个节点，next指向后一个节点，使用data来存数据 STL如下实现上述结构//类似双向链表 struct _List_node_base { _List_no
STL中的vector与list插入数据速度比较
xjtuse2014的博客
08-18 5125
对于忘list中插入数据，很好理解，分配一个新的结点空间，添加到链表尾部即可；对于往vectorz中添加数据，需要判断当前控件是否够用，不够用的话需要再次分配稍大的一些空间，然后把已有的元素拷贝到新的空间区域，然后释放已有的空间。也许有人觉得这个拷贝操作很费时，觉得没有list添加的速度快，然而，事实并不是这样…..#include <iostream> #include <time.h> #in
关联表多数据的批量insert （批量导入，测试19W条数据用时46秒）
愿我如星君如月 ... 夜夜流光相皎洁 ...
07-21 5751
maven/Java/web/bootstrap/dataTable/app开发QQ群：566862629。希望更多人一起帮助我学习。一、业务需求 ：作多个批量导入 ，根据业务不同，每条数据导入前作各种验证， 导入后提示验证失败的所有数据和原因。二、思路： 1. 批量导入用 jdbc 直连数据库 addBatch方法实现 ，不走 Mybatis ，...
webgoat-server-8.2.2.zip
07-21
解压即可得到webgoat-server-8.2.2.jar
人工智能行业深度报告：WAIC2024，国产AI+应用“百花齐放”
最新发布
07-21
2024年世界人工智能大会（WAIC 2024）上，国产AI+应用生态呈现“百花齐放”的局面 1. WAIC 2024：国产 AI+应用生态“百花齐放” 多家厂商携大模型及AI应用成果亮相展会，涵盖金山办公、科大讯飞、华为、商汤等知名企业。 OpenAI 禁令加速推动国产 AI 生态，国产大模型性能持续提升，缩小与海外差距。 预计未来国产 AI+行业应用将迎来“百花齐放”局面，商业空间加速打开。 2. 国产大模型加速迭代，代表性厂商生态加速构建 科大讯飞 发布星火 V4.0 大模型，全面对标 GPT-4 Turbo，多模态能力显著提升。 星火医疗和教育垂类模型能力升级，赋能行业应用落地。 推出星火企业智能平台，赋能企业构建岗位专属助手。 华为 发布盘古大模型 5.0 系列，包括不同参数规模，适用于多种场景。 推出盘古具身智能大模型，推动人形机器人技术升级。 盘古 5.0 赋能华为小艺升级，在多个行业落地应用。 商汤 发布“日日新 5.5”模型，交互体验对标 GPT-4o，多模态能力实现突破。 推出面向 C 端用户的可控人物视频生成模型 Vimi。 率先实现原生多模态大模型车端部署
java毕设&课设-基于web的实验室管理系统（自动排课功能的实现）.zip
07-21
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
丽珠集团000513.SZ公司首次覆盖报告：创新药与高壁垒制剂齐推进，多元化布局促发展.pdf
07-21
丽珠集团000513.SZ公司首次覆盖报告：创新药与高壁垒制剂齐推进，多元化布局促发展
C++ STL详解：链表容器list与核心概念
"该资源是关于C++标准模板库STL的第9章内容，特别是聚焦于链表容器list的讲解。" 在C++中，STL（Standard Template Library）是一个核心的库，包含了多种通用的数据结构和算法，极大地提高了程序员的效率。STL由...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值