第十二章 STL 之 list

happy 天堂

已于 2022-07-10 20:05:38 修改

阅读量62

点赞数

分类专栏： C++重难点文章标签： c++ list 数据结构

于 2022-07-10 20:05:09 首次发布

原文链接：https://blog.csdn.net/it_xiangqiang/article/details/109592038

版权

C++重难点专栏收录该内容

13 篇文章 5 订阅

订阅专栏

1 list基本概念

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

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

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

结点的组成： 一个是存储数据元素的 数据域 ，另一个是存储下一个结点地址的 指针域

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

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

list的优点：

采用动态存储分配，不会造成内存浪费和溢出

链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间 ( 指针域 ) 和时间（遍历）额外耗费较大

List 有一个重要的性质，插入操作和删除操作都不会造成原有 list 迭代器的失效，这在 vector 是不成立的。

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

2 list构造函数

功能描述：

创建 list 容器

函数原型：

list<T> lst; //list 采用采用模板类实现 , 对象的默认构造形式：

list(beg,end); // 构造函数将 [beg, end) 区间中的元素拷贝给本身。

list(n,elem); // 构造函数将 n 个 elem 拷贝给本身。

list(const list &lst); // 拷贝构造函数。

示例：

#include <list> 
void printList(const list<int>& L) 
{ 
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) 
	{
		cout << *it << " ";
	
	}cout << endl; 
}

void test01() 
{
	list<int>L1;
	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(10, 1000); 
	printList(L4);
}

int main() 
{ 
	test01();
	return 0;
}

输出结果：

10 20 30 40
10 20 30 40
10 20 30 40
1000 1000 1000 1000 1000 1000 1000 1000 1000 1000

总结： list 构造方式同其他几个 STL 常用容器，熟练掌握即可

3 list 赋值和交换

功能描述：

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

函数原型：

assign(beg, end); // 将 [beg, end) 区间中的数据拷贝赋值给本身。

assign(n, elem); // 将 n 个 elem 拷贝赋值给本身。

list& operator=(const list &lst); // 重载等号操作符

swap(lst); // 将 lst 与本身的元素互换。

示例：

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

//赋值和交换 
void test01()
{
	list<int>L1; 
	L1.push_back(10); 
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1); 
	
	//赋值
	list<int>L2;
	L2 = L1;
	printList(L2); 
	
	list<int>L3; 
	L3.assign(L2.begin(), L2.end());
	printList(L3);
	
	list<int>L4; 
	L4.assign(10, 100);
	printList(L4); 
}


//交换 
void test02() 
{ 
	list<int>L1;
	L1.push_back(10); 
	L1.push_back(20);
	L1.push_back(30); 
	L1.push_back(40); 
	
	list<int>L2; 
	L2.assign(10, 100);
	
	cout << "交换前： " << endl;
	printList(L1); 
	printList(L2);
	cout << endl;
	
	
	L1.swap(L2);
	cout << "交换后： " << endl; 
	printList(L1);
	printList(L2); 
}

int main() 
{ 
	test01(); 
	test02(); 
	return 0;
}

输出结果：

10 20 30 40
10 20 30 40
10 20 30 40
100 100 100 100 100 100 100 100 100 100
交换前：
10 20 30 40
100 100 100 100 100 100 100 100 100 100

交换后：
100 100 100 100 100 100 100 100 100 100
10 20 30 40

总结：list赋值和交换操作能够灵活运用即可

4 list 大小操作

功能描述：

对 list 容器的大小进行操作

函数原型：

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

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

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

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

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

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

示例：

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

//大小操作 
void test01() 
{ 
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	if (L1.empty()) 
	{ 
		cout << "L1为空" << endl;
	}
	else 
	{ 
		cout << "L1不为空" << endl;
		cout << "L1的大小为： " << L1.size() << endl; 
	}
	
	//重新指定大小
	L1.resize(10);
	printList(L1); 
	L1.resize(2);
	printList(L1); 
}

int main() 
{
	test01(); 
	return 0; 
}

输出结果：

L1不为空
L1的大小为： 4
10 20 30 40 0 0 0 0 0 0
10 20

总结：

判断是否为空 --- empty

返回元素个数 --- size

重新指定个数 --- resize

5 list 插入和删除

功能描述：

对 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 值匹配的元素。

示例：

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

//插入和删除 
void test01() 
{
	list<int> L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30); 
	
	//头插
	L.push_front(100); 
	L.push_front(200); 
	L.push_front(300); 
	printList(L); 
	
	//尾删 
	L.pop_back();
	printList(L); 
	
	//头删 
	L.pop_front();
	printList(L); 
	
	//插入 
	list<int>::iterator it = L.begin(); 
	L.insert(++it, 1000);
	printList(L); 
	
	//删除
	it = L.begin();
	L.erase(++it); 
	printList(L);
	
	//移除 
	L.push_back(10000);
	L.push_back(10000); 
	L.push_back(10000); 
	printList(L); 
	
	L.remove(10000); 
	printList(L); 
	
	//清空
	L.clear();
	printList(L); 
}

int main() 
{ 
	test01(); 
	return 0;
}

输出结果：

300 200 100 10 20 30
300 200 100 10 20
200 100 10 20
200 1000 100 10 20
200 100 10 20
200 100 10 20 10000 10000 10000
200 100 10 20

总结：

尾插 --- push_back

尾删 --- pop_back

头插 --- push_front

头删 --- pop_front

插入 --- insert

删除 --- erase

移除 --- remove

清空 --- clear

6 list 数据存取

功能描述：

对 list 容器中数据进行存取

函数原型：

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

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

示例：

//数据存取 
void test01() 
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20); 
	L1.push_back(30);
	L1.push_back(40); 
	
	//cout << L1.at(0) << endl;//错误 不支持at访问数据
	//cout << L1[0] << endl; //错误 不支持[]方式访问数据 
	
	cout << "第一个元素为： " << L1.front() << endl;
	cout << "最后一个元素为： " << L1.back() << endl;
	
	//list容器的迭代器是双向迭代器，不支持随机访问 
	list<int>::iterator it = L1.begin(); 
	
	//it = it + 1;//错误，不可以跳跃访问，即使是+1 
}

int main() 
{ 
	test01();
	return 0; 
}

输出结果：

第一个元素为： 10
最后一个元素为： 40

总结：

list 容器中不可以通过 [] 或者 at 方式访问数据

返回第一个元素 --- front

返回最后一个元素 --- back

7 list 反转和排序

功能描述：

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

函数原型：

reverse() ; // 反转链表

sort() ; // 链表排序

示例：

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 val1, int val2) 
{ 
	return val1 > val2; 
}

//反转和排序 
void test01() 
{ 
	list<int> L;
	L.push_back(90);
	L.push_back(30);
	L.push_back(20);
	L.push_back(70); 
	printList(L); 
	
	//反转容器的元素
	L.reverse(); 
	printList(L); 
	
	//排序
	L.sort(); 
	//默认的排序规则 从小到大
	printList(L); 

	L.sort(myCompare); 
	//指定规则，从大到小
	printList(L); 
}

int main() 
{ 
	test01();
	return 0;
}

输出结果：

90 30 20 70
70 20 30 90
20 30 70 90
90 70 30 20

总结：

反转 --- reverse

排序 --- sort （成员函数）

8 排序案例

案例描述：将 Person 自定义数据类型进行排序， Person 中属性有姓名、年龄、身高

排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

示例：

#include <list> 
#include <string> 

class Person 
{ 
public: 
Person(string name, int age , int height)
{
m_Name = name; 
m_Age = age;
m_Height = height;
} 
public:
	string m_Name;//姓名 

	int m_Age; //年龄 

	int m_Height; //身高
};

bool ComparePerson(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 test01() 
{
	list<Person> L; 
	Person p1("刘备", 35, 175); 
	Person p2("曹操", 45, 180);
	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);
	
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) 
	{ 
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << " 身高： " << it->m_Height << endl; 
	}
	
	cout << "---------------------------------" << endl;
	L.sort(ComparePerson); 
	
	//排序 
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) 
	{ 
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << " 身高： " << it->m_Height << endl;
	} 
}

int main() 
{ 
	test01();
	return 0;
}

输出结果：

姓名： 刘备 年龄： 35 身高： 175
姓名： 曹操 年龄： 45 身高： 180
姓名： 孙权 年龄： 40 身高： 170
姓名： 赵云 年龄： 25 身高： 190
姓名： 张飞 年龄： 35 身高： 160
姓名： 关羽 年龄： 35 身高： 200
---------------------------------
姓名： 赵云 年龄： 25 身高： 190
姓名： 关羽 年龄： 35 身高： 200
姓名： 刘备 年龄： 35 身高： 175
姓名： 张飞 年龄： 35 身高： 160
姓名： 孙权 年龄： 40 身高： 170
姓名： 曹操 年龄： 45 身高： 180

总结：

对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序

高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂

happy 天堂

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十二章 STL 之 list

输出结果：总结：list构造方式同其他几个STL常用容器，熟练掌握即可输出结果：总结：list赋值和交换操作能够灵活运用即可输出结果：总结：判断是否为空 --- empty 返回元素个数 --- size 重新指定个数 --- resize5 list 插入和删除功能描述：对list容器进行数据的插入和删除函数原型： push_back(elem);
复制链接

扫一扫