C++入门：STL——list

最新推荐文章于 2023-05-28 14:47:21 发布
最新推荐文章于 2023-05-28 14:47:21 发布
阅读量164 收藏
点赞数
分类专栏： C++

序列式容器：每个元素均有固定位置，取决于插入时机和地点，和元素值无关。

一、list

List由双向链表（doubly linked list）实现而成，元素也存放在堆中，每个元素都是放在一块内存中，他的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机存取变得非常没有效率，因此它没有提供[]操作符的重载。但是由于链表的特点，它可以很有效率的支持任意地方的插入和删除操作。

二、list的初始化

list<int> a; //定义一个int类型的列表a 
list<int> a(10); //定义一个int类型的列表a，并设置初始大小为10 
list<int> a(10, 1); //定义一个int类型的列表a，并设置初始大小为10且初始值都为1 
list<int> b(a); //定义并用列表a初始化列表b 
deque<int> b(a.begin(), ++a.end()); //将列表a中的第1个元素作为列表b的初始值

三、list的大小和容量

  • 容器大小： lst.size();
  • 更改容器大小： lst.resize();
  • 最大允许的数量值：lst.max_size();
  • 容器判空： lst.empty();
#include "stdafx.h"
#include <iostream>
#include <list>

using namespace std;

int main(int argc, char* argv[])
{
    list<int> lst;
    for (int i = 0; i<6; i++)
    {
        lst.push_back(i);
    }

    cout << "元素大小： " << lst.size() << endl;
    cout << "元素最大容量： " << lst.max_size() << endl;
    lst.resize(0); //更改元素大小
    cout << "元素大小： " << lst.size() << endl;
    if (lst.empty())
        cout << "元素为空" << endl;

    return 0;
}

/*
元素大小： 6
元素最大容量： 357913941
元素大小： 0
元素为空
*/

四、list的插入：push_front()、push_back() 和 insert()

  • 头部添加元素：lst.push_front(const T& x);
  • 末尾添加元素： lst.push_back(const T& x);
  • 任意位置插入一个元素： lst.insert(iterator it, const T& x);
  • 任意位置插入n个相同元素： lst.insert(iterator it, int n, const T& x);
  • 插入另一个向量的[forst,last]间的数据： lst.insert(iterator it, iterator first, iterator last);
#include "stdafx.h"
#include <iostream>
#include <list>

using namespace std;

int main(int argc, char* argv[])
{
    list<int> lst;

    //头部增加元素
    lst.push_front(4);
    //末尾添加元素
    lst.push_back(5);
    //任意位置插入一个元素
    list<int>::iterator it = lst.begin();
    lst.insert(it, 2);
    //任意位置插入n个相同元素
    lst.insert(lst.begin(), 3, 9);
    //插入另一个向量的[forst,last]间的数据
    list<int> lst2(5, 8);
    lst.insert(lst.begin(), lst2.begin(), ++lst2.begin());

    //display lst
    cout << "lst: ";
    for (it = lst.begin(); it != lst.end(); it++)
        cout << *it << " ";
    cout << endl;

    return 0;
}

/*
lst: 8 9 9 9 2 4 5
*/

五、 list的删除：pop_front()、pop_back()和erase()

  • 头部删除元素：lst.pop_front();
  • 末尾删除元素： lst.pop_back();
  • 任意位置删除一个元素： lst.erase(iterator it);
  • 删除[first,last]之间的元素： lst.erase(iterator first, iterator last);
  • 清空所有元素： lst.clear();
#include "stdafx.h"
#include <iostream>
#include <list>

using namespace std;

int main(int argc, char* argv[])
{
    list<int> lst;
    for (int i = 0; i < 8; i++)
        lst.push_back(i);

    //头部删除元素
    lst.pop_front();
    //末尾删除元素
    lst.pop_back();
    //任意位置删除一个元素
    list<int>::iterator it = lst.begin();
    lst.erase(it);
    //删除[first,last]之间的元素
    lst.erase(lst.begin(), ++lst.begin());

    //display lst
    cout << "lst: ";
    for (it = lst.begin(); it != lst.end(); it++)
        cout << *it << " ";
    cout << endl;

    //清空所有元素
    lst.clear();

    //clear, display lst
    cout << "clear,lst: ";
    for (it = lst.begin(); it != lst.end(); it++)
        cout << *it << " ";
    cout << endl;

    return 0;
}

/*
lst: 3 4 5 6
clear,lst:
*/

六、list的遍历：借助迭代器或者下标法

  • 开始迭代器指针：lst.begin();
  • 末尾迭代器指针：lst.end(); //指向最后一个元素的下一个位置
  • 指向常量的开始迭代器指针： lst.cbegin(); //意思就是不能通过这个指针来修改所指的内容，但还是可以通过其他方式修改的，而且指针也是可以移动的。
  • 指向常量的末尾迭代器指针： lst.cend();
  • 反向迭代器指针，指向最后一个元素： lst.rbegin();
  • 反向迭代器指针，指向第一个元素的前一个元素： lst.rend();
#include "stdafx.h"
#include <iostream>
#include <list>

using namespace std;

int main(int argc, char* argv[])
{
    list<int> lst;
    lst.push_back(1);
    lst.push_back(2);
    lst.push_back(3);

    cout << "*(lst.begin()): " << *(lst.begin()) << endl;
    cout << "*(lst.end()): " << *(--lst.end()) << endl;
    cout << "*(lst.cbegin()): " << *(lst.cbegin()) << endl;
    cout << "*(lst.cend()): " << *(--lst.cend()) << endl;
    cout << "*(lst.rbegin()): " << *(lst.rbegin()) << endl;
    cout << "*(lst.rend()): " << *(--lst.rend()) << endl;
    cout << endl;

    return 0;
}

/*
*(lst.begin()): 1
*(lst.end()): 3
*(lst.cbegin()): 1
*(lst.cend()): 3
*(lst.rbegin()): 3
*(lst.rend()): 1
*/

七、list的访问函数

  • 访问第一个元素： lst.front();
  • 访问最后一个元素： lst.back();
#include "stdafx.h"
#include <iostream>
#include <list>

using namespace std;

int main(int argc, char* argv[])
{
    list<int> lst;
    for (int i = 0; i < 6; i++)
        lst.push_back(i);

    //访问第一个元素
    cout << "访问第一个元素: " << lst.front() << endl;
    //访问最后一个元素
    cout << "访问最后一个元素: " << lst.back() << endl;

    return 0;
}

/*
访问第一个元素: 0
访问最后一个元素: 5
*/

八、list的其他函数

  • 多个元素赋值： lst.assign(int nSize, const T& x); //类似于初始化时用数组进行赋值
  • 交换两个同类型容器的元素： swap(list&, list&); 或 lst.swap(list&);
  • 合并两个列表的元素（默认升序排列）： lst.merge();
  • 在任意位置拼接入另一个list： lst.splice(iterator it, list&);
  • 删除容器中相邻的重复元素：lst.unique();
#include "stdafx.h"
#include <iostream>
#include <list>

using namespace std;

int main(int argc, char* argv[])
{
    //多个元素赋值s
    list<int> lst1;
    lst1.assign(3, 1);
    list<int> lst2;
    lst2.assign(3, 2);
    //交换两个容器的元素
    //swap(lst1, lst2); //ok
    lst1.swap(lst2);

    //display lst1
    cout << "交换后的lst1: ";
    list<int>::iterator it;
    for (it = lst1.begin(); it!=lst1.end(); it++)
        cout << *it << " ";
    cout << endl;
    //display lst2
    cout << "交换后的lst2: ";
    for (it = lst2.begin(); it != lst2.end(); it++)
        cout << *it << " ";
    cout << endl;

    list<int> lst3;
    lst3.assign(3, 3);
    list<int> lst4;
    lst4.assign(3, 4);
    //合并两个列表的元素
    lst4.merge(lst3); //不是简单的拼接，而是会升序排列
    cout << "合并后的lst4: ";
    for (it = lst4.begin(); it != lst4.end(); it++)
        cout << *it << " ";
    cout << endl;

    list<int> lst5;
    lst5.assign(3, 5);
    list<int> lst6;
    lst6.assign(3, 6);
    //在lst6的第2个元素处，拼接入lst5
    lst6.splice(++lst6.begin(), lst5);
    cout << "拼接后的lst6: ";
    for (it = lst6.begin(); it != lst6.end(); it++)
        cout << *it << " ";
    cout << endl;

    //删除容器中相邻的重复元素
    list<int> lst7;
    lst7.push_back(1);
    lst7.push_back(1);
    lst7.push_back(2);
    lst7.push_back(2);
    lst7.push_back(3);
    lst7.push_back(2);
    lst7.unique();
    cout << "删除容器中相邻的重复元素后的lst7: ";
    for (it = lst7.begin(); it != lst7.end(); it++)
        cout << *it << " ";
    cout << endl;

    return 0;
}

/*
交换后的lst1: 2 2 2
交换后的lst2: 1 1 1
合并后的lst4: 3 3 3 4 4 4
拼接后的lst6: 6 5 5 5 6 6
删除容器中相邻的重复元素后的lst7: 1 2 3 2
*/

 

M_Z_G_Y
关注
专栏目录
C++STL之list
qq_54866651的博客
06-01 202
的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。迭代到该位置，在这段位置上迭代需要线性的时间开销；最大的缺陷是不支持任意位置的随机访问，比如：要访问。在插入元素时，要给所有的迭代器重新赋值，因为插入。迭代器失效即迭代器所指向的节点的无效，即该节。
C++入门到精通 ——第七章 STL标准模板库大局观
LY. RoboLab
02-25 888
七、STL标准模板库大局观 Author: XFFer_
[C++ STL] list使用详解
weixin_30289831的博客
01-12 177
一、list介绍： List由双向链表（doubly linked list）实现而成，元素也存放在堆中，每个元素都是放在一块内存中，他的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机存取变得非常没有效率，因此它没有提供[]操作符的重载。但是由于链表的特点，它可以很有效率的支持任意地方的插入和删除操作。 二、用法 1、头文件 #include <list> /...
stl-list
yiyele的博客
09-02 4229
STL之list容器详解List 容器list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。使用list容器之前必须加上头文件：#include;list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using names
C++ STL List
yearning_mjw的博客
11-27 309
个人学习记录
C++ STL list
XXXTENTAC1ON的博客
04-20 447
Listlist 的介绍list 的使用list 的创建访问、push_front、erase、unique、removelist 与 vector 的区别总结 list 的介绍 list是序列容器，允许在序列中的任何位置执行固定O(1)时间的插入和删除操作，并在两个方向上进行迭代 list容器使用双链表实现，双链表将每个元素存储在不同的存储位置，每个节点通过next，prev指针链接成顺序表 list与其他基本标准序列容器（array、vector和deque）相比，list通常在容器内的任何位置插入、
C++中STL容器之双向链表——list
75 69 69 80 32 67 79 68 73 78 71 33
02-23 784
文章目录1.list介绍2.list的成员函数2.1 构造、拷贝和析构函数2.2 非变动性操作2.3 赋值操作2.4 元素存取操作2.5 迭代器相关函数2.6 插入元素2.6 移除元素2.7 特殊变动性操作2.8 排序和翻转操作3.应用实例参考资料 1.list介绍 list 是顺序容器的一种，且list 是一个双向链表(double linked list)。双向链表的每个元素都有两个指针域，一...
C++程序设计教程——设计思想与实现习题代码答案
12-07
STL包括容器（如vector、list、set）、迭代器、算法和函数对象，这些都是现代C++编程不可或缺的部分。此外，这部分还可能涉及文件I/O和流的概念，让学习者了解如何在程序中读写文件。 通过这些章节的习题代码答案，...
C++学习笔记——STL学习笔记
Stretch9776的博客
09-06 733
前言 参考： 【刷题】刷题常用STL函数整理合集_zhuhongde的博客-CSDN博客_stl常用函数 STL教程：C++ STL快速入门（非常详细） (biancheng.net) C++ STL 教程 | 菜鸟教程 (runoob.com) 容器： C/C++STL常用容器用法总结_帅比王的博客-CSDN博客_c 容器 1 STL基础 STL(standard template library) ，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是 C++ 提供的一个基础模板的集合
c++入门语法及使用 - c++学习路线（csdn）————程序.pdf
12-01
以下是对C++入门语法和使用路线的详细阐述。 一、C++基础 C++的基础部分主要涵盖基本数据类型、运算符、逻辑循环语句和复合数据类型。 1. 基本数据类型 C++支持多种基本数据类型，包括bool、char、int、float和...
C++STL之＜list＞
gangaue的博客
06-11 1318
本篇文章进行STL中list（双向链表）序列容器的学习！！！【list的文档介绍】list底层原理图(双向链表)： list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口举个栗子🌰： 【注意】举个栗子🌰： 举个栗子🌰： 举个栗子🌰： 注意：二个接口返回的是这个数据的引用，引用可以充当左值… 举个栗子🌰1️⃣： 举个栗子🌰2️⃣： 举个栗子🌰3️⃣： 迭代器失效：举个栗子🌰： 🍁2、list模拟实现 🍂..........
C++:STL--List
最新发布
小青菜的博客
05-28 1511
C++list的学习
C++STL中的容器-list
rainxuanz的博客
08-22 320
C++STL中的容器-list list就是链表，在C语言中我们想使用链表都是自己去实现的，实现起来倒不难，但是如果有现成的高效的链表可以使用的话，我们就不需要重复造轮子了。STL就提供了list容器给我们。 list是一个双向链表，而单链表对应的容器则是foward_list。 list即双向链表的优点是插入和删除元素都比较快捷，缺点是不能随机访问元素。 初始化方式就大同小异了，跟vec...
C++ STL list详解
dengguan2720的博客
07-24 271
一.解释： list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，list不仅是一个双向链表，而其还是一个环状双向链表。所以它只需要一个指针，便可以完整实现整个链表。list有一个重要性质：插入操作（insert）和合并操作（splice）都不会 造成原有的list迭代器失效。甚至 list...
C++ STL - List
C++++ ++
05-28 363
list 类 （VC++） C++标准库列表类是序列容器的类模板，用于在线性排列中维护其元素，并允许在序列中的任何位置进行有效的插入和删除。 序列存储为双向链接的元素列表，每个包含一些 Type 类型的成员。 语法 template <class Type, class Allocator= allocator<Type>> class list 参数 Type 要存储在列表中的元素数据类型。 Allocator 表示所存储分配器对象的类型，该分配器对象封装有关列表的内存分配和
c++ STL list
菜鸟的自我提升
07-24 626
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。 使用list容器之前必须加上STL的list容器的头文件：#include; list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using namespace ...
C++ STL入门：标准模板库详解
"这篇文档是关于C++标准模板库（STL）的简介，主要讨论了STL的概念、目的、重要性以及其中的关键概念——模板和泛型编程。" STL，全称Standard Template Library，是C++编程语言的一个重要组成部分，它是一个标准化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值