C++ list容器

最新推荐文章于 2024-06-03 09:14:44 发布
最新推荐文章于 2024-06-03 09:14:44 发布
阅读量74 收藏
点赞数
分类专栏： C++知识总结 文章标签： 链表 容器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62142545/article/details/126445645
版权

list容器

list容器

功能：将数据进行链式存储

链表：是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
STL中的链表是一个双向循环链表。由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。

list的优点：
1、采用动态存储分配，不会造成内存浪费和溢出。
2、链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。

list的缺点：
1、链表灵活，但是空间（指针域）和时间（遍历）额外消耗较大。
2、list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器失效，这在vector是不成立的。

总结：STL中list和vector是两个最常被使用的容器，各有优缺点。

list构造函数

  • 功能描述：
    创建list容器
  • 函数原型：

list< T> lst;//list采用模板类实现，对象的默认构造形式。
list(beg,end);//构造函数将[beg,end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test1()
{
	list<int> l1;//创建list容器，默认构造

	l1.push_back(10);//添加数据
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);
	printList(l1);

	list <int> l2(l1.begin(), l1.end());//区间方式构造
	printList(l2);

	list <int> l3(l2);//拷贝构造
	printList(l3);

	list<int> l4(5, 100);//n个elem
	printList(l4);
}
int main(void)
{
	test1();
	return 0;
}

总结：list构造方式同其它几个STL常用容器。

list赋值和交换

  • 功能描述：
    给list容器进行赋值，以及交换list容器
  • 函数原型：

assign(beg,end);//将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem);//将n个elem拷贝赋值给本身
list& operator=(const list &list);//重载等号操作符
swap(lst);//将lst与本身的元素互换

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test1()//赋值
{
	list<int> l1;

	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);
	printList(l1);

	list <int> l2;//operator=方式赋值
		l2 = l1;
	printList(l2);

	list<int> l3;
	l3.assign(l2.begin(), l2.end());//assign方式
	printList(l3);

	list<int> l4;
	l4.assign(5, 100);
	printList(l4);
}
void test2()//交换
{
	list<int> l1;

	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	list<int> l2;
	l2.assign(5, 100);

	cout << "交换前：" << endl;
	printList(l1);
	printList(l2);

	l1.swap(l2);

	cout << "交换后：" << endl;
	printList(l1);
	printList(l2);
}
int main(void)
{
	test1();
	test2();
	return 0;
	}

list大小操作

  • 功能描述：
    对list容器的大小进行操作
  • 函数原型：

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);///重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(num,elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test1()
{
	list<int> l1;

	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);
	printList(l1);

	if (l1.empty()) {//判断容器是否为空
		cout << "l1为空" << endl;
	}
	else {
		cout << "l1不为空" << endl;
		cout << "l1的元素个数为：" << l1.size() << endl;
	}
	//重新指定个数
	/*l1.resize(10);
	printList(l1);*/

	l1.resize(10, 5);
	printList(l1);

	l1.resize(2);
	printList(l1);
}

int main(void)
{
	test1();
	return 0;
}

总结：
判断是否为空-----empty
返回元素个数-----size
重新指定大小-----resize

list插入和删除

  • 功能描述：
    对list容器进行插入、删除操作
  • 函数原型：

push_back(elel);//在容器尾部加入元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert( pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据。
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test1()
{
	list<int> l1;

	l1.push_back(10);//尾插
	l1.push_back(20);
	l1.push_front(100);//头插
	l1.push_front(200);
	printList(l1);//200 100 10 20

	l1.pop_back();//尾删
	l1.pop_front();//头删
	printList(l1);//100 10

	l1.insert(l1.begin(),1000);//插入
	printList(l1);//1000 100 10

	list<int>::iterator it = l1.begin();//迭代器偏移
	l1.insert(++it, 2000);
	printList(l1);//1000 2000 100 10

	it = l1.begin();//重新归为初始位置
	l1.erase(++it);//删除第二个元素
	printList(l1);//1000 100 10

	l1.push_back(10000);
	l1.push_back(10000);
	l1.push_back(10000);
	printList(l1);//1000 100 10 10000 10000 10000
	l1.remove(10000);//移除(上面三个10000全部移除)
	printList(l1);//1000 100 10

	l1.clear();//清空
	printList(l1);
}

int main(void)
{
	test1();
	return 0;
}

总结：
尾插-----push_back
尾删-----pop_back
头删-----pop_front
头插-----push_front
插入-----insert
删除-----erase
移除-----remove
清空-----clear

list数据存取

  • 功能描述：
    对list容器中数据进行存取
  • 函数原型：

front();//返回第一个元素。
back();//返回最后一个元素。

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test1()
{
	list<int> l1;

	l1.push_back(10);//尾插
	l1.push_back(20);
	l1.push_front(100);//头插
	l1.push_front(200);
	printList(l1);//200 100 10 20

	cout << "第一个元素为：" << l1.front() << endl;//200
	cout << "第一个元素为：" << l1.back() << endl;//20
	//验证迭代器不支持随机访问
	list<int>::iterator it = l1.begin();
	it++;
	it--;//说明支持双向
//	it + 1;不支持随机访问
}

int main(void)
{
	test1();
	return 0;
}

总结：
1、list容器中不可以通过[]或者at方式访问数据
2、返回第一个元素-----front
3、返回最后一个元素-----back

list反转和排序

  • 功能描述：
    将容器中的元素反转，以及将容器中的数据进行排序。
  • 函数原型：

reverse();//反转链表
sort();//链表排序

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
bool myCompare(int v1, int v2)
{
	return v1 > v2;//降序就让第一个数大于第二个数
}
void test1()
{
	list<int> l1;

	l1.push_back(10);//尾插
	l1.push_back(20);
	l1.push_front(100);//头插
	l1.push_front(200);

	cout << "反转前：" << endl;
	printList(l1);//200 100 10 20
	cout << "反转后：" << endl;
	l1.reverse();//反转操作
	printList(l1);//20 10 100 200
	cout << endl;
	//所有不支持随机访问的迭代器，不可以用标准算法
	//不支持随机访问的迭代器的容器，内部会提供对应的算法
	l1.push_back(30);
	l1.push_back(40);

	cout << "排序前：" << endl;
	printList(l1);//20 10 100 200 30 40

	l1.sort();//默认排序是升序

	cout << "升序排序后：" << endl;
	printList(l1);//10 20 30 40 100 200

	l1.sort(myCompare);
	cout << "降序排序后：" << endl;
	printList(l1);
}

int main(void)
{
	test1();
	return 0;
}

总结：
反转-----reverse
排序-----sort（成员函数）

list容器自定义类型排序案例（案例）

  • 案例描述：
    将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高。
  • 排序规则：
    按照年龄进行升序，如果年龄相同按照身高进行降序。
#include <iostream>
#include <list>
#include <string>
using namespace std;
class Person
{
public:
	Person(string name, int age, int height)
	{
		this->m_age = age;
		this->m_height = height;
		this->m_name = name;
	}
	int m_age;
	int m_height;
	string m_name;
};
bool compare(Person& p1, Person& p2)
{
	if (p1.m_age == p2.m_age) {
		return p1.m_height > p2.m_height;//年龄相同身高降序
	}
	else {
		return p1.m_age < p2.m_age;
	}
}
void test1()
{
	list<Person> L;
	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 100);
	Person p3("孙权", 40, 170);
	Person p4("赵云", 25, 190);
	Person p5("张飞", 35, 160);
	Person p6("关羽", 35, 200);

	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);
	cout << "排序前：" << endl;
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {//遍历一遍
		cout << "姓名:" << (*it).m_name << " 年龄:" << (*it).m_age << " 身高:" << (*it).m_height << endl;

	}
	L.sort(compare);
	cout << "--------------------------------" << endl;
	cout << "排序后：" << endl;
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名:" << (*it).m_name << " 年龄:" << (*it).m_age << " 身高:" << (*it).m_height << endl;
	}
}

int main(void)
{
	test1();
	return 0;
}

总结：
1、对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序。
2、高级排序只是在排序规则上再进行一次逻辑规则制定。

匿名459
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++——List容器
qq_64662686的博客
10-06 772
list容器学习
【C++】list容器
debug...
08-02 422
C++标准模板库链表 list
【C++】list 容器最全详解（什么是list? list容器的常用接口有那些？）
最新发布
weixin_45031801的博客
06-03 1799
最近在刷 leetcode 的时候，发现 list都还没弄明白吗，但是 STL 的强大是众所周知滴，早晚都是要解决滴，因此专门写下这篇文章，以供自己复习和各位老铁使用，快速的回忆 list的用法，让你找回自信，不用再竞赛的时候颜面尽失。
【C++】list容器介绍及使用
qq_44631587的博客
08-20 4027
list底层结构，构造函数，拷贝构造函数；list的三种遍历方式；insert、erase、swap、resize、remove、remove_if、unique、sort、reverse等接口的使用方法；list迭代器失效问题，list与vector的对比
C++之list容器
一起coding，一起嗨。
06-06 1360
/自定义数据类型排序public:int m_Age;// 排序规则 按照年龄进行升序，如果年龄相同按照身高进行降序} else {//按照年龄进行升序，如果年龄相同按照身高进行降序Person p1("刘备", 35, 175);Person p2("曹操", 45, 180);Person p3("孙权", 40, 170);Person p4("赵云", 25, 190);Person p5("张飞", 35, 160);
C++中List容器的使用
xbj319wz的博客
04-28 679
优点：可以对任意位置进行快速插入和删除元素缺点：容器的遍历速度没有数组快。占用空间比数组大。由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。总结：STL中list和vector是两个最常被使用的容器，各有各的缺点。
P215~222C++list容器学习笔记.docx
04-13
C++ list容器学习笔记 本文主要介绍C++中的list容器，包括list容器的基本概念、构造函数、赋值和交换等。 list容器基本概念 list容器是一种链表（linked list），其物理存储单元上非连续的存储结构，数据元素的...
c++中容器之总结篇
09-03
C++中的容器是标准模板库(STL)的重要组成部分，它们提供了高效的数据结构，方便程序员管理和操作数据。本文将深入探讨两种主要的容器类别——顺序容器和关联容器。 **顺序容器**，如其名，是按照元素插入的顺序来...
C++语言 STL容器list总结
01-21
在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问 STL 中的list 就是一 双向链表，可高效地...
C++实现STL容器之List
04-08
C++实现STL容器之List
c++容器常见操作
05-29
- **构造转换**：可以使用容器构造函数将一种容器转换为另一种，例如`std::list(vec.begin(), vec.end())` 将向量转换为列表。 - **assign()**：某些容器支持从另一个容器赋值，如`std::vector<int> newVec; ...
C++学习之list容器
热门推荐
百锦再的博客
02-19 2万+
不支持直接通过下标方式访问元素，但可以通过迭代器来访问和修改元素。是由多个节点组成的双向链表结构，每个节点包含数据元素和指向前一个节点和后一个节点的指针。：由于是双向链表，插入或删除元素时不需要移动其他元素，只需要修改相邻节点之间的指针。std::list`是一个非常灵活的容器，特别适合需要频繁进行插入和删除操作的场景。中的节点是动态分配的，可以根据需要动态增加或减少节点数量，因此不需要提前指定大小。提供了迭代器（iterator）来遍历容器中的元素，包括正向迭代器、逆向迭代器等。容器的翻转和排序操作。
C++征途 --- List链表容器
qq_51947882的博客
08-31 969
4.但是对于只支持前移和后移的迭代器a而言：1.它们不能够有 a = a +1 , a = a + 2这种操作，比如链表，它的每一个节点的地址都是随机分布的，第一个节点和第二个节点的内存空间的地址可能差很多也可能只差1，如果我们盲目的 a = a+1的话，得到的地址对应的内存空间可能是未分配的空间，这就会导致程序出错。1.假设我们让一个迭代器指向节点a，只要节点a不消失，无论链表怎样变动，迭代器指向的内存空间始终不变，我们使用这个迭代器的时候依然能访问到这个节点a --- 迭代器不失效。...
c++---list容器
m0_50046535的博客
04-21 534
1、list基本概念 功能：将数据进行链式存储 链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 链表的优点： 可以对任意的位置进行快速插入或删除元素，修改指针即可，不需要移动大量元素 采用动态存储分配，不会造成内存的浪费和溢出 缺点： 容器遍历速度没有数组快，占用空间 比 数组 大 STL中的链表是一个双向循环链表 list有一个重要性
(C++初阶) list的基本使用与模拟实现
qq_57594025的博客
07-05 1915
目录一 知识点总结二 list的基本使用1.list遍历方式2.list排序（不推荐）3.list数据操作三 list 模拟实现1 List.h2 List.cpp1.原生指针可以当做天然迭代器使用。其实vector/string 的迭代器就是原生指针。但是，如list物理空间不连续的容器，使用原生指针就已经无法完成迭代器的功能了，所以就需要用迭代器去封装list的节点指针node*，重载这个类的* ++ 等运算符，去模拟指针的访问行为。2.迭代器的作用：可以让我们不用在意容器的底层结构到底是数组、链表、树
【C++ STL】-- list介绍与使用
weixin_64609308的博客
11-02 632
STL的 list 的介绍和使用
C++ STL中LIST常见用法归纳总结
lxndy的博客
05-18 723
C++ STL中LIST常见用法归纳总结
c++标准模板（STL）（std::list）（五）
qq_40788199的博客
10-03 901
std::list 是支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。它通常实现为双向链表。与 std::forward_list 相比，此容器提供双向迭代但在空间上效率稍低。 在 list 内或在数个 list 间添加、移除和移动元素不会非法化迭代器或引用。迭代器仅在对应元素被删除时非法化。
C++ list 容器
11-27
以下是一个简单的C++ list容器的例子： ```cpp #include #include <list> using namespace std; int main() { list<int> lt; lt.push_back(1); lt.push_back(2); lt.push_back(3); lt.push_back(4); for ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值