C++学习笔记——STL【容器：list】

最新推荐文章于 2024-07-17 18:07:42 发布
最新推荐文章于 2024-07-17 18:07:42 发布
阅读量248 收藏
点赞数
分类专栏： C++进阶提高 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43359484/article/details/127415490
版权

list 的基本概念

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

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

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

链表的节点由两部分组成：

  • 存储数据元素的数据域
  • 存储下一个结点地址的指针域

STL中的 list 是一个双向循环链表。

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

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<string>
#include<list>

using namespace std;

// 打印输出list
void print_list1(const list<int>& mylist) {
	// 通过只读迭代器遍历链表
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

int main() {
	/*无参数构造函数*/
	list<int> list1;
	/*在容器的尾部插入一个元素*/
	list1.push_back(1);
	list1.push_back(2);
	list1.push_back(3);
	list1.push_back(4);
	print_list1(list1); // 1 2 3 4

	/*使用list1迭代器指向区间元素构造list2*/
	list<int> list2(list1.begin(),list1.end());
	print_list1(list2);// 1 2 3 4

	/*使用 5 个888构造 list3*/
	list<int> list3(5, 888);
	print_list1(list3); // 888 888 888 888 888

	/*拷贝构造函数*/
	list<int> list4(list3);
	print_list1(list4); // 888 888 888 888 888

	return 0;
}

赋值和交换

功能描述：

  • 给list容器进行赋值，以及交换list容器

函数原型：

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

using namespace std;

void print_list2(const list<int>& mylist) {
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

int main() {
	list<int> list1;
	list1.push_back(1);
	list1.push_back(2);
	list1.push_back(3);
	list1.push_back(4);
	print_list2(list1); // 1 2 3 4

	/*将list1 的第二个至倒数第二个区间内的元素复制到list2中*/
	list<int> list2;
	list2.assign(list1.begin(), list1.end()); 
	print_list2(list2); // 1 2 3 4

	/*将 5 个 999 存入list3中*/
	list<int> list3;
	list3.assign(5,9);
	print_list2(list3); // 9 9 9 9 9

	/*重载赋值操作符*/
	list<int> list4 = list3;
	print_list2(list4); // 9 9 9 9 9

	/*交换 list1 和 list 中的元素*/
	list1.swap(list4);
	print_list2(list1); // 9 9 9 9 9
	print_list2(list4); // 1 2 3 4

	return 0;
}

大小操作

功能描述：

  • 对list容器的大小进行操作

函数原型：

  • size(); //返回容器中元素的个数

  • empty(); //判断容器是否为空

  • resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

    ​ //如果容器变短，则末尾超出容器长度的元素被删除。

  • resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

#include<iostream>
#include<string>
#include<list>

using namespace std;

void print_list3(const list<int>& mylist) {
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

int main() {
	list<int>list1;
	for (int i = 0; i < 10; i++) {
		list1.push_back(i*i+1);
	}
	print_list3(list1); // 1 2 5 10 17 26 37 50 65 82
	/*判断list是否为空*/
	cout << (list1.empty() ? "为空" : "不为空" )<< endl;
	/*获取list的大小*/
	cout << "list1的大小：" << list1.size() << endl;

	/*重新设置list1的大小，list1变大多余的位置以0填充*/
	list1.resize(15);
	print_list3(list1); // 1 2 5 10 17 26 37 50 65 82 0 0 0 0 0

	/*重新设置list1的大小，list1变大多余的位置以999填充*/
	list1.resize(20,1);
	print_list3(list1); // 1 2 5 10 17 26 37 50 65 82 0 0 0 0 0 1 1 1 1 1

	/*重新设置list1的大小，list1变短，原来超出的部分直接舍弃*/
	list1.resize(5);
	print_list3(list1); // 1 2 5 10 17

	return 0;
}

插入和删除

功能描述：

  • 对list容器进行数据的插入和删除

函数原型：

  • push_back(elem);//在容器尾部加入一个元素
  • 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<string>
#include<list>

using namespace std;

void print_list4(const list<int>& mylist) {
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

int main() {
	list<int> mylist;
	/*在容器尾部插入元素*/
	mylist.push_back(1);
	mylist.push_back(2);
	/*在容器头部插入元素*/
	mylist.push_front(3);
	mylist.push_front(4);
	print_list4(mylist); // 4 3 1 2

	list<int>list2;
	list2.push_back(11);
	list2.push_back(22);
	list2.push_back(33);
	print_list4(list2); // 11 22 33

	/*在迭代器指向位置插入元素*/
	list<int>::iterator p = mylist.begin(); // 此时p指向4
	mylist.insert(p++, 888); // 在第一个元素位置插入888，迭代器后移一个位置
	print_list4(mylist); // 888 4 3 1 2，此时 p 指向 3
	mylist.insert(p++, 999); // 在第三个元素位置插入999，迭代器后移一个位置
	print_list4(mylist); // 888 4 999 3 1 2 ，此时p指向 1
	mylist.insert(p,2, 777); // 在第四个元素位置插入2个777
	print_list4(mylist); // 888 4 999 3 777 777 1 2

	/*此时p指向 元素1*/
	/*将list2的[begin(),end())区间内的元素存入mylist的第7个元素位置*/
	mylist.insert(p, list2.begin(), list2.end());
	print_list4(mylist); // 888 4 999 3 777 777 11 22 33 1 2

	/*删除list2 [begin(),end())区间内的元素*/
	list2.erase(list2.begin(), list2.end());
	cout << list2.size() << endl; // 0

	/*此时 p 指向 元素1*/
	/*删除mylist 中 p 指向的元素1*/
	list<int>::iterator p_next = mylist.erase(p); // 返回被删除元素的下一个元素的位置
	print_list4(mylist); // 888 4 999 3 777 777 11 22 33 2
	cout << "下一个元素是：" << *p_next << endl; // 2

	/*删除指定值*/
	mylist.remove(777); // 删除值为 777 的元素
	print_list4(mylist); // 888 4 999 3 11 22 33 2

	/*清空整个 mylist*/
	mylist.clear();
	cout << mylist.size() << endl; // 0

	return 0;
}

数据存取

功能描述：

  • 对list容器中数据进行存取

函数原型：

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

list的双向迭代器
双向迭代器，不支持随机访问，只能以递增或递减的方式逐步向前或者向后访问。

#include<iostream>
#include<string>
#include<list>

using namespace std;

void print_list5(const list<int>& mylist) {
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

int main() {
	list<int> mylist;
	/*在容器尾部插入元素*/
	mylist.push_back(1);
	mylist.push_back(2);
	/*在容器头部插入元素*/
	mylist.push_front(3);
	mylist.push_front(4);
	print_list5(mylist); // 4 3 1 2

	/*获取第一个元素*/
	int first = mylist.front();
	int last = mylist.back();
	cout << first << endl; // 4
	cout << last << endl; // 2

	/*list的迭代器是双向迭代器，不允许跳跃访问，即使是 p = p + 1 的操作*/
	list<int>::iterator p = mylist.begin(); // 指向第一个位置
	// p = p + 1; // 错误
	// p = p - 1; // 错误
	// p = p + 2; // 错误
	p++; // 只能递增，后移一位
	cout << *p << endl; // 3
	p--; // 前移一位
	cout << *p << endl; // 4

	return 0;
}

反转和排序

功能描述：

  • 将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

  • reverse(); //反转链表
  • sort(); //链表排序
#include<iostream>
#include<string>
#include<list>

using namespace std;

void print_list6(const list<int>& mylist) {
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

int main() {
	list<int> mylist;
	/*在容器尾部插入元素*/
	mylist.push_back(1);
	mylist.push_back(2);
	mylist.push_back(3);
	mylist.push_back(4);
	mylist.push_back(5);
	mylist.push_back(6);
	print_list6(mylist); // 1 2 3 4 5 6

	/*list反转*/
	mylist.reverse();
	print_list6(mylist); // 6 5 4 3 2 1

	/*清空list*/
	mylist.clear();

	/*随机种子*/
	srand((unsigned int)time(NULL));
	for (int i = 0; i < 10; i++) {
		// 生成 [99,21] 之间的一个随机整数
		int n = (rand() % (99 - 21 + 1)) + 21;
		mylist.push_back(n);
	}
	print_list6(mylist); // 51 26 47 57 29 28 41 94 53 37

	/*mylist 排序：*/
	mylist.sort();
	print_list6(mylist); // 26 28 29 37 41 47 51 53 57 94

	return 0;
}

排序案例

案例需求：

  • 创建一个 Person 类，成员变量：姓名、身高、体重
  • 将多个 Pseron 对象存入list容器
  • 根据 Person 的身高（先）、体重（后）进行升序排序
#include<iostream>
#include<string>
#include<list>

using namespace std;

void print_list7(const list<int>& mylist) {
	for (list<int>::const_iterator ite = mylist.begin(); ite != mylist.end(); ite++) {
		cout << *ite << " ";
	}
	cout << endl;
}

class Person {
public:
	string name;
	int height;
	int weight;

	Person(string name,int weight,int height) {
		this->name = name;
		this->weight = weight;
		this->height = height;
	}
};
// 两个Person 对象比较大小,先按身高排序，后按体重排序，升序
bool person_conmare(Person& p1, Person& p2) {
	if (p1.height == p2.height) {
		return p1.weight <= p2.weight;
	}
	else {
		return p1.height <= p2.height;
	}
}

/*重写 左移操作符*/
ostream& operator<<(ostream& out, const Person& person) {
	out << "姓名：" << person.name << " 身高：" << person.height << " 体重：" << person.weight;
	return out;
}

// 重载 字符串与int使用加号运算
string operator+(string& content, int number) {
	string temp = "";
	char t = 0;
	while (true) {
		t = number % 10 + '0';
		temp = t + temp;
		number /= 10;
		if (number == 0) {
			return content + temp;
		}
	}
}
// 重载字符串与int使用 += 运算
// 由于+=会调用+号，所以 += 必须写在 + 号重载后面
string& operator+=(string& content, int number) {
	return content = content + number;
}


/*打印输出 list*/
void print_list7(list<Person>& mylist) {
	for (list<Person>::const_iterator p = mylist.begin(); p != mylist.end(); p++) {
		cout << *p << endl;
	}
}

int main() {
	/*随机种子*/
	srand((unsigned int)time(NULL));

	list<Person> ps;
	// 姓名
	
	for (int i = 0; i < 10; i++) {
		// 身高 cm 150到170之间
		int h = (rand() % (170 - 150 + 1)) + 150;
		// 体重 kg 50 到70之间
		int w = (rand() % (70 - 50 + 1)) + 50;
		string name = "Person-";
		name += i;
		Person p(name, w, h);
		ps.push_back(p);
	}
	print_list7(ps);
	cout << "***********" << endl;
	/*排序*/
	ps.sort(person_conmare);
	print_list7(ps);

}

姓名：Person-0 身高：165 体重：60
姓名：Person-1 身高：161 体重：56
姓名：Person-2 身高：159 体重：64
姓名：Person-3 身高：163 体重：55
姓名：Person-4 身高：157 体重：52
姓名：Person-5 身高：155 体重：64
姓名：Person-6 身高：165 体重：69
姓名：Person-7 身高：169 体重：65
姓名：Person-8 身高：168 体重：56
姓名：Person-9 身高：167 体重：50
***********
姓名：Person-5 身高：155 体重：64
姓名：Person-4 身高：157 体重：52
姓名：Person-2 身高：159 体重：64
姓名：Person-1 身高：161 体重：56
姓名：Person-3 身高：163 体重：55
姓名：Person-0 身高：165 体重：60
姓名：Person-6 身高：165 体重：69
姓名：Person-9 身高：167 体重：50
姓名：Person-8 身高：168 体重：56
姓名：Person-7 身高：169 体重：65
米兰@de小铁匠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++/STL/读书笔记
01-07
C++/STL/读书笔记是对C++标准模板库（Standard Template Library，简称STL）深入学习的重要资源。STL是C++编程中不可或缺的一部分，它提供了高效且可重用的数据结构和算法，极大地提高了代码的编写效率和可读性。...
王道C++46期学习笔记记录.zip
10-18
《王道C++46期学习笔记记录》是一份详细且深入的C++学习资源，旨在帮助编程初学者以及有经验的开发者进一步提升C++技能。C++是一种强大的、通用的编程语言，以其面向对象的特性、高效性能和丰富的库支持而闻名。这46...
1.9 C++学习之list&set&map
剑雨巍巍的博客
10-28 581
文章目录3.7 list容器3.7.1 基本概念3.7.2 构造函数3.7.3 赋值和交换3.7.4 大小操作3.7.5 插入和删除3.7.6 数据存取3.7.7 反转和排序3.7.8 排序案例3.8 set/ multiset 容器3.8.1 基本概念3.8.2 构造和赋值3.8.3 大小和交换3.8.4 插入和删除3.8.5 查找和统计3.8.6 set和multiset区别3.8.7 pa...
C++入门——list容器
beilizhang的博客
07-12 203
参考链接 1.https://www.bilibili.com/video/BV1et411b73Z?p=215&t=3 list容器 链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 STL中的链表是一个双向循环链表 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器 list的优点 1.采
[c++学习笔记21]：list容器
dinnersize的博客
07-15 248
1 list基本概念 功能：将数据进行链式存储 链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 STL中的链表是一个双向循环链表。 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器 list的优点： 采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即可，不需要
C++学习笔记——STL【算法：遍历算法】
米兰的小铁匠
10-22 344
C++学习：STL中的遍历算法
C++学习笔记——STL常用容器——list
潘芝的博客
03-01 236
list容器的功能：将数据进行链式存储。 链表：一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。链表由一系列结点组成，结点由存储数据元素的数据域和存储下一个结点地址的指针域组成。 STL中的链表是一个双向循环链表。 list的优点： 采用动态存储分配，不会造成内存浪费和溢出； 执行插入和删除方便，修改指针的指向即可，不需要移动大量元素。 list的缺...
C++学习笔记 —— STL
不想随波逐流的大学生一枚，我们每个人都在努力奔跑
01-15 707
黑马程序员C++对于STL课程学习笔记，并加了一些个人理解和网络所查找的一些资料助于理解
C++学习笔记 —— STL之list（链表）
Charles Ren's Tech Blog
05-15 1229
https://www.cnblogs.com/scandy-yuan/archive/2013/01/08/2851324.html 实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。O(1)复杂度 #include <iostream> #include <list> #include <vector> #include <algorithm> // g++ -std=c++11 list.cc -o test && tes
C++学习笔记——STL学习笔记
Stretch9776的博客
09-06 664
前言 参考： 【刷题】刷题常用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++个人学习笔记归纳总结.rar_C++STL_X9H3_c++个人笔记总结
09-23
总的来说，"C++个人学习笔记归纳总结"涵盖了C++编程的基础到进阶内容，从语法基础到STL的深入学习，再到实际项目的应用。通过这样的学习过程，开发者不仅可以掌握C++语言，还能培养良好的编程思维，为未来解决复杂...
P215~222C++list容器学习笔记.docx
04-13
C++ list容器学习笔记 本文主要介绍C++中的list容器，包括list容器的基本概念、构造函数、赋值和交换等。 list容器基本概念 list容器是一种链表（linked list），其物理存储单元上非连续的存储结构，数据元素的...
C++基础笔记，到STL库
03-14
9. **STL(Standard Template Library)**：STL是C++标准库的一部分，提供了容器（如vector、list、map等）、迭代器、算法和函数对象等组件，极大提高了代码的可读性和复用性。 10. **C++新特性**：随着标准的更新，...
C++学习笔记——STL
米兰的小铁匠
10-17 137
C++学习笔记：STL
小欧吃苹果-OPPO 2024届校招正式批笔试题-数据开发（C卷）
sigd的博客
07-16 500
小欧吃苹果，拓扑排序处理贪心问题。
学懂C语言系列（三）：C语言基本语法
最新发布
martian665的专栏
07-17 547
学懂C语言系列,C语言基本语法
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 995
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
C++学习笔记：STL顺序容器操作详解
"这篇学习笔记主要探讨了C++中的STL顺序容器，包括vector, list和deque，并介绍了如何向这些容器中添加元素。此外，笔记还提到了C++的学习资源和课程大纲，以及C++的发展历程和行业地位。" 在C++的Standard ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值