C++ 11 STL list

于 2024-08-14 18:10:00 发布
阅读量241 收藏 2
点赞数 5
分类专栏： STL c/c++ c++11 文章标签： c++ list 开发语言 STL C++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gopher9511/article/details/141197248
版权
c/c++ 同时被 3 个专栏收录
85 篇文章 0 订阅
订阅专栏
c++11
16 篇文章 0 订阅
订阅专栏
STL
5 篇文章 0 订阅
订阅专栏

list

list是C++标准模板库（STL）中的一个容器，用于存储元素的双向链表。它提供了高效的插入和删除操作，但在随机访问方面不如vector高效。

//todo list

# include <iostream>
#include <list>
using namespace std;

void print(list<int> & li){
    //使用迭代器遍历list
    for(list<int>::iterator it=li.begin();it!=li.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;


}

int main() {
    list<int> li={1,2,3,4,5};
    cout<<li.front()<<endl;//1
    cout<<li.back()<<endl;//5
    print(li);


    li.push_back(6);//添加元素
    print(li); //1 2 3 4 5 6

    li.pop_back();//删除最后一个元素
    print(li); //1 2 3 4 5

    li.pop_front();//删除第一个元素
    print(li);//2 3 4 5

    li.sort();//排序
    print(li);//2 3 4 5

    li.reverse();//反转
    print(li);//5 4 3 2

    li.remove(3);//删除所有值为3的元素
    print(li);//2 4 5

    li.unique();//删除重复元素
    print(li);//2 4 5

    li.resize(1);//调整大小
    print(li);//2

    li.clear();//清空list
    print(li);

    li.insert(li.begin(),10);//在第一个位置插入元素
    print(li);//10

    li.erase(li.begin());//删除第一个元素
    print(li);//10

    
    return 0;
}



# if 1
//todo list
#include <iostream>
#include <list>
using namespace std;


void print(list<int> & li){
    list<int> ::iterator it ;

    for (it=li.begin();it!=li.end();++it){
        cout<<*it<<" ";
    }
    cout<<endl;
}

int main(){
    int arr[10]={1,2,3,4};
    list<int> li(arr,arr+4);
    list<int> li2(li.begin(),li.end());
    print(li);
    print(li2);

    cout<<li2.size()<<endl;//4
    while (!li2.empty()){
        cout<<li2.back();
        li2.pop_back();
    }
    cout<<li2.size()<<endl;//0

    
    return 0;
}


# endif

list 比较

比较对象要重载==和!=运算符


int main(){

    //比较基本数据类型
    list<int> li1={1,2,3,4};
    list<int> li2={1,2,3,4};

    if(li1==li2){
        cout<<"=="<<endl;
    } else{
        cout<<"!="<<endl;
    }

    //比较对象要重载==和!=运算符
    
    return 0;
}

插入

#include <iostream>
#include <list>
#include <iterator>
using namespace std;

void print(list<int> & li){
    //for(auto it=li.begin();it!=li.end();++it){  cout<<*it<<" ";  }

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

}
int main(){
    list<int> li={1,2,3,4,5};
    li.insert(li.begin(),333);//开头插入333
    print(li);//333 1 2 3 4 5
    li.insert(li.end(),2,666);//末尾插入2个666
    print(li);//333 1 2 3 4 5 666 666

    int arr[]={6,7,8};
    li.insert(li.end(),arr,arr+3);//插入一个范围
    print(li);//333 1 2 3 4 5 666 666 6 7 8

    li.insert(li.end(),{77,77,77});//插入一个范围
    print(li);//333 1 2 3 4 5 666 666 6 7 8 77 77 77

    li.emplace(li.begin(),111);//在开头插入111
    print(li);//111 333 1 2 3 4 5 666 666 6 7 8 77 77 77

    li.emplace_back(222);//在末尾插入222
    print(li);//111 333 1 2 3 4 5 666 666 6 7 8 77 77 77 222

    li.emplace_front(333);//在开头插入333
    print(li);//333 111 333 1 2 3 4 5 666 666 6 7 8 77 77 77 222

    return 0;
}

删除

erase删除元素

#include <iostream>
#include <list>
#include <iterator>
using namespace std;

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

int main(){
    list<int> li={1,2,3,4,5};

    li.erase(li.begin());//删除第一个元素
    print(li);//2 3 4 5

    //list并非线性,所以不能+1
    //li.erase(li.begin()+1);

    list<int>::iterator it=li.begin();//获取迭代器
    advance(it,1);//移动到第二个元素
    li.erase(it);//删除第二个元素
    print(li);//2 4 5

    //支持 ++ -- 前缀和后缀运算符
    li.erase(++li.begin());//删除第二个元素
    print(li);//2 5

    //删除范围
    li.erase(li.begin(),li.end());//删除所有元素
    print(li);//(空)

    return 0;
}

remove删除元素

//todo remove删除元素
#include <iostream>
#include <list>
#include <iterator>
using namespace std;

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

int main(){
    list<int> li={1,2,3,4,5};

    li.remove(3);//删除所有值为3的元素
    print(li);//1 2 4 5
    cout<<li.size()<<endl;//4

    //删除>=3的元素
    li.remove_if([](int x){
        if(x>=3)return true;
        else return false;
    });//返回值是bool的函数
    print(li);//1 2
    cout<<li.size()<<endl;//2
    return 0;
}

list 特有

排序

基本类型


//todo list排序
#include <iostream>
#include <list>
#include <iterator>
using namespace std;

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

int main(){
    list<int> li={5,3,1,4,2};

    li.sort(less<int>());
    li.sort();//默认less<int>()
    print(li);//1 2 3 4 5
    li.sort(greater<int>());
    print(li);//5 4 3 2 1

    //greater_equal是greater的升级版,即>= 
    li.sort(greater_equal<int>());
    //less_equal是less的升级版,即<=
    li.sort(less_equal<int>());
    
    return 0;
    
}

对象排序 和 取反not2

//todo 排序对象
#include <iostream>
#include <list>

using namespace std;

class A
{
public:
    A()
    {
        cout<<"无参构造函数"<<this<<endl;
    }
    A(int i):_data(i)
    {
        cout<<"有参构造函数"<<this<<endl;
    }
    A(const A & other)
    {
        this->_data=other._data;
        cout<<"拷贝构造"<<this<<" from "<<&other<<endl;
    }
    A& operator=(const A & other)
    {
        this->_data=other._data;
        cout<<"拷贝赋值"<<this<<" from "<<&other<<endl;
        return *this;
    }
    ~A()
    {
        cout<<"析构函数"<<this<<endl;
    }

    //重载<运算符
    bool operator<(const A & other) const
    {
        return _data<other._data;
    }
    void print(){
        cout<<_data<<" ";
    }
private:
    int _data;
};

int main(){
    list<A> li={A(3),A(2),A(1)};
    li.sort(less<A>());//需要重载<运算符
    for (auto & it:li){
        it.print();
        cout<<endl;  // 1   2    3
    }

    //使用not1单参数的时候取反
    //使用not2两个参数的时候取反
    li.sort(not2(less<A>()));//取反
    for (auto & it:li){
        it.print();
        cout<<endl; // 3   2    1
    }
    return 0;
}

unique删除重复元素

//todo unique删除重复元素
#include <iostream>
#include <list>

using namespace std;


int main(){
    list<int> li={1,2,3,3,4,5,5,4,3,2,1};
    //li.unique();//去除了连续的重复元素
    for (auto & it:li){
        cout<<it<<" "; //1 2 3 4 5 4 3 2 1
    }
    cout<<endl;

    li.sort();//先排序
    li.unique();//再去重
    for (auto & it:li){
        cout<<it<<" "; //1 2 3 4 5
    }
    cout<<endl;

    //自定义比较函数
    li.unique([](int a,int b){
        if(a==b ){
            return true;
        }else{
            return false;
        }
    });


    return 0;
}

拼接相关操作

//todo 拼接相关操作
# include <iostream>
# include <list>
using namespace std;

void print(list<int> & li){
    for(auto it=li.begin();it!=li.end();++it){
        cout<<*it<<" ";
    }
    cout<<endl;
}

int main(){
    list<int> li1={1,2,3,4,5};
    list<int> li2={6,7,8,9,10};


    //li1.splice(li1.begin(),li2);//拼接到末尾
    //print(li1);//6 7 8 9 10 1 2 3 4 5
    //print(li2);//拼接时发生移动,li2移动到li1,li2为空

//    li1.splice(li1.end(),li2,li2.begin());
//    print(li1);//1 2 3 4 5 6
//    print(li2);//7 8 9 10

//    auto itr=li1.begin();
//    advance(itr,3);//移动到第四个元素
//    li1.splice(itr,li2,li2.begin(),li2.end());
//    print(li1);//1 2 3 6 7 8 9 10 4 5

    list<int> li3={100,244,37,4,5};
    list<int> li4={61,7,5558,97,10};

    //需要merge有序需要先排序再merge
    li3.merge(li4);//61 7 100 244 37 4 5 5558 97 10
    print(li3);//1 2 3 4 5 6 7 8 9 10
    print(li4);//空
}

#include <list>
#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;

// 打印两个list的内容
void printLists(const list<int>& l1, const list<int>& l2)
{
    cout << "list1: ";
    // 使用copy算法和ostream_iterator将list1的内容输出到cout
    copy(l1.cbegin(), l1.cend(), ostream_iterator<int>(cout, " "));
    cout << endl << "list2: ";
    // 使用copy算法和ostream_iterator将list2的内容输出到cout
    copy(l2.cbegin(), l2.cend(), ostream_iterator<int>(cout, " "));
    cout << endl << endl;
}

int main()
{
    // 创建两个list对象
    list<int> list1, list2;

    // 向list1和list2中添加元素
    for (int i = 0; i < 6; ++i)
    {
        list1.push_back(i);  // 在list1的末尾添加元素
        list2.push_front(i); // 在list2的头部添加元素
    }

    // 打印list1和list2的内容
    printLists(list1, list2);

    // 在list2中找到值为3的元素，并将list1的所有元素移动到该位置之前
    list2.splice(find(list2.begin(), list2.end(), 3), list1);

    // 打印list1和list2的内容
    printLists(list1, list2);

    // 将list2的第一个元素移动到list2的末尾
    list2.splice(list2.end(), list2, list2.begin());

    // 对list2进行排序
    list2.sort();

    // 将list2的内容赋值给list1
    list1 = list2;

    // 移除list2中的重复元素
    list2.unique();

    // 打印list1和list2的内容
    printLists(list1, list2);

    // 将list2合并到list1中
    list1.merge(list2);

    // 打印list1和list2的内容
    printLists(list1, list2);

    return 0;
}

不支持随机访问

list 容器由于采用了双向迭代器，不支持随机访问，所以标准库的 merge(),
sort()等功能函数都不适用，list 单独实现了 merge()，sort()等函数。

#include <iostream>
#include <list>
#include <iterator>
#include <algorithm>
using namespace std;

int main()
{
    // 创建一个list对象li，并初始化其内容为{1, 3, 5, 7, 9, 2, 4, 6, 8, 10}
    list<int> li = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

    // 对li进行排序
    li.sort();

    // 遍历并输出排序后的li
    for (auto &i : li)
        cout << i << endl;

    // 创建另一个list对象li2，并初始化其内容为{11, 12, 15, 13, 14}
    list<int> li2 = {11, 12, 15, 13, 14};

    // 将li2合并到li中
    li.merge(li2);

    // 对合并后的li进行排序
    li.sort();

    // 遍历并输出排序后的li
    for (auto &i : li)
        cout << i << "\t";
    cout << endl;

    // 遍历并输出li2的内容
    for (auto &i : li2)
        cout << i << "\t";
    cout << endl;

    return 0;
}

高效的插入和删除

插入和删除是高效的，元素不需移动，内存仅是指针移动

#include <iostream>
#include <list>
#include <iterator>
#include <algorithm>
using namespace std;

// 定义类A
class A
{
public:
    // 无参构造函数
    A()
    {
        cout << "无参构造函数 " << this << endl;
    }

    // 有参构造函数
    A(int i) : _data(i)
    {
        cout << "有参构造函数 " << this << endl;
    }

    // 拷贝构造函数
    A(const A & other)
    {
        cout << "拷贝构造 " << this << " from " << &other << endl;
    }

    // 拷贝赋值运算符
    A& operator=(const A & other)
    {
        cout << "拷贝赋值 " << this << " from " << &other << endl;
        return *this;
    }

    // 析构函数
    ~A()
    {
        cout << "析构函数 " << this << endl;
    }

private:
    int _data; // 私有成员变量
};

int main()
{
    // 创建一个存储A类型对象的list
    list<A> la;

    // 使用assign方法将list填充为10个临时A对象
    la.assign(10, A());

    // 删除list的第一个元素
    la.erase(la.begin());

    // 在list的开始位置插入一个新的临时A对象
    la.insert(la.begin(), A());

    return 0;
}

插入和删除不会使迭代器失效。 删除建议使用remove/remove_if

MarkTop1
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++——STL之list详解
weixin_59055853的博客
12-22 1208
list是一个序列容器，支持常数时间（也就是O(1)）内进行任意位置的插入删除，还支持双向迭代。list容器作为双向链表实现;双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。与其他基本标准序列容器（array, vector and deque）相比，list在容器内已经获得迭代器的任何位置插入、提取和移动元素时通常表现更好，因此在大量使用这些元素的算法中也是如此，例如排序算法。与其他序列容器相比，主要缺点是它们无法通过其位置直接访问元素;
【C++】STL容器之list
DanteKing的博客
02-08 1213
stl之list的详解和模拟实现
C++:STL--List
小青菜的博客
05-28 1272
C++list的学习
C++ STL库详解：list
2201_75880188的博客
01-21 1826
详细介绍了list的功能和用法，列举了list常用的接口，并进行代码演练和实操。介绍了iterator迭代器失效的原因和解决措施。列举并分析了vector和list的区别。
【C/C++】STL详解
热门推荐
明月沉江春雾晓
08-17 17万+
学校并未教授C++, 当初接触的C++的STL, 也是皮毛而已。 结合对Java的集合框架等内容的认识，回顾这部分内容，收获很大。 文章目录概述STL六大组件简介三大组件介绍1. 容器2. 算法3. 迭代器常用容器1. string容器string容器基本概念string容器常用操作2. vector容器vector容器基本概念vector迭代器vector的数据结构vector常用API操作...
C++ STL: list使用及源码剖析
暮色年华的博客
02-15 1219
push_front()，push_back（），pop_front()， pop_back()在insert和erase的基础上实现。如果指针node指向置于尾端的一个空白节点，node就能符合stl对于前闭后开区间的要求，这样以下函数便能轻易完成。链表最后使用一个指针指向环形链表的空白节点，空白节点指向头节点，这样就形成了一个环了。可以看出list节点是一个双向链表，next指向下一个节点，prev指向前一个节点。node是指向list节点的一个指针，可以使用这个指针表示整个环状双向链表。
C++ [STL之list的使用]
ARMCSKGT的博客
05-28 8715
vector是一片连续的空间，在数据访问上性能较好，但是任意位置插入删除性能较低，头插头删性能亦是如此；此时在这种需要频繁插入的场景下，显然链表是一种更好的选择，STL中实现了带头双选循环链表，本次我们来介绍该如何使用STL中的链表list！list的使用介绍到这里就结束了，相信学会了list在需要频繁增删数据的场景下我们那个轻松应对，对于vector和list两者各有优劣，应对不同的场景我们需要合理应用甚至结合使用！
c++STL中的list
Slowstep_的博客
09-30 996
c++STL中的list容器
【C++】STL标准库之list
qq_40376612的博客
05-05 843
STL之list简介
C++ STL list详解
星羽空间
02-06 749
C++ STL list详解
C++中 STL list详解及简单实例
08-30
在C++编程中，STL（Standard Template Library，标准模板库）是不可或缺的一部分，它提供了一系列高效的数据结构和算法。其中，`list`容器是STL中的一个重要组件，本篇文章将详细解析`list`的内部实现和使用方法，并...
TinySTL-master_STL_C++11_
09-29
TinySTL是一个轻量级的C++11标准模板库（STL）实现，它旨在提供与标准STL相似的功能，但体积更小、更适合学习和理解。STL是C++编程中的重要组成部分，它包括了容器、迭代器、算法和函数对象等核心组件，极大地提高了...
C++语言 STL容器list总结
01-21
STL 中的list 就是一 双向链表，可高效地进行插入删除元素。 list不支持随机访问。所以没有 at(pos)和operator[]。 list 对象list1, list2 分别有元素list1(1,2,3),list2(4,5,6) 。list< int>::iterator it; 构造...
c++ stl list总结
11-04
`forward_list`是C++11引入的单向链表容器，不支持反向迭代，比`list`更节省内存，但在某些操作上效率稍低。 总结，C++ STL的`list`容器是处理动态数据结构，尤其是需要高效插入和删除操作时的利器。理解和熟练...
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 905
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 476
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 271
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 496
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++的内存分区
m0_63764282的博客
08-14 304
在C++中，程序的内存主要被分为几个不同的区域（或称为“分区”），这些区域用于存储不同类型的数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MarkTop1

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

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

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

打赏作者

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

抵扣说明：

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

余额充值