list 与 forward_list 中的一些特殊方法

最新推荐文章于 2024-08-09 14:41:30 发布
最新推荐文章于 2024-08-09 14:41:30 发布
阅读量102 收藏
点赞数
分类专栏： C++ 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43203889/article/details/117028290
版权
C++ 同时被 2 个专栏收录
53 篇文章 3 订阅
订阅专栏
容器
8 篇文章 0 订阅
订阅专栏

list 与 forward_list 中的一些特殊方法

list 与 forward_list 有一些其他序列容器没有的函数。

list 中的 splice 约等于 splice_after，使用方式一模一样，只是拼接的位置位于第一参数之后。

函数名函数作用
splice将元素从 list 拼接到 list
remove删除具有特定值的元素
remove_if删除满足条件的元素
unique删除重复值
merge合并排序列表
sort对容器中的元素进行排序
reverse颠倒元素的顺序

splice

示例：
void test1() {
    list<int> a{ 0,1,2,3,4,5 };
    list<int> b{ 6,7,8,9,10 };
    //第一种 splice 
    //第一个参数为拼接的位置，第二个参数为拼接的 list
    a.splice(a.end(), b);
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
    //第二种 splice 
    //第一个参数为拼接的位置，第二个参数为拼接的 list，第三个参数为 list 的迭代器
    //将 list 的迭代器上的值拼接到需拼接的位置上（第一参数）。
    list<int> c{ 11,12,13 };
    a.splice(a.end(), c, c.begin());
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
    //第三种 splice 
    //第一个参数为拼接的位置，第二个参数为拼接的 list
    //第三个参数为 list 需拼接的开始迭代器，第四个参数为 list 需拼接的结束迭代器
    //将 list 的 [第三参数,第四参数) 上的值拼接到需拼接的位置上（第一参数）。
    list<int> d{ 12,13,14,15 };
    a.splice(a.end(), d, d.begin(), d.end());
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：0 1 2 3 4 5 6 7 8 9 10
a 中的元素：0 1 2 3 4 5 6 7 8 9 10 11
a 中的元素：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

remove

示例：
void test2() {
    //这里有两个 5
    list<int> a{ 0,1,2,3,4,5,5 };
    //第一参数为 val
    //从容器中删除所有等于第一参数的元素。
    a.remove(5);

    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：0 1 2 3 4

remove_if

示例：
void test3() {
    list<int> a{ 0,1,2,3,4,5 };
    //第一参数为 Predicate  
    auto pre = [](const int& a) {
        return a > 3;
    };
    a.remove_if(pre);

    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：0 1 2 3

unique

示例：
void test4() {
    list<int> a{ 0,1,2,3,4,5,5 };
    //unique 分为有参与无参两个方式
    //无参时，从容器中每个相等元素的连续组中除去除第一个元素外的所有元素。
    //注意，只有与列表容器紧邻的元素相比，该元素才从列表容器中删除。
    a.unique();
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
    //有参时，从容器中除去除第一个元素外的其他符合条件的所有元素。
    auto binary_pre = [](const int& a, const int& b) {
        return (fabs(a - b) < 5);
    };
    list<int> b{ 1,2,3,4,5,6,10,15 };
    b.unique(binary_pre);

    cout << "a 中的元素：";
    for (auto& t : b) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：0 1 2 3 4 5
b 中的元素：1 6 15

merge

示例：
void test5() {
    list<int> a{ 0,1,2,3,4,5 };
    list<int> b{ 1,2,3,4,5,6 };
    //merge 的前提是两个有序 list
    //第一种直接合并
    a.merge(b);
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
    //第二种设置条件
    list<double> c{ 1.4,2.2,2.9,3.1,3.7,7.1 };
    list<double> d{ 2.1 };
    auto cmp = [](const double& a, const double& b) {
        return (int(a) < int(b));
    };
    c.merge(d, cmp);

    cout << "c 中的元素：";
    for (auto& t : c) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：0 1 1 2 2 3 3 4 4 5 5 6
c 中的元素：1.4 2.2 2.9 2.1 3.1 3.7 7.1

sort

示例：
void test6() {
    list<int> a{ 0,1,2,3,4,5 };
    auto cmp = [](const int& a, const int& b) {
        return a > b;
    };
    //支持有参和无参两种方式
    //a.sort()  或 a.sort(Compare)
    a.sort(cmp);
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;

    a.sort();
    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：5 4 3 2 1 0
a 中的元素：0 1 2 3 4 5

reverse

示例：
void test7() {
    list<int> a{ 0,1,2,3,4,5 };
    a.reverse();

    cout << "a 中的元素：";
    for (auto& t : a) {
        cout << t << " ";
    }
    cout << endl;
}
输出：
a 中的元素：5 4 3 2 1 0

测试程序

#include <list>
#include <iostream>
using namespace std;
class MYTEST {
public:
	void test1() {
		list<int> a{ 0,1,2,3,4,5 };
		list<int> b{ 6,7,8,9,10 };
		//第一种 splice 
		//第一个参数为拼接的位置，第二个参数为拼接的 list
		a.splice(a.end(), b);
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		//第二种 splice 
		//第一个参数为拼接的位置，第二个参数为拼接的 list，第三个参数为 list 的迭代器
		//将 list 的迭代器上的值拼接到需拼接的位置上（第一参数）。
		list<int> c{ 11,12,13 };
		a.splice(a.end(), c, c.begin());
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		//第三种 splice 
		//第一个参数为拼接的位置，第二个参数为拼接的 list
		//第三个参数为 list 需拼接的开始迭代器，第四个参数为 list 需拼接的结束迭代器
		//将 list 的 [第三参数,第四参数) 上的值拼接到需拼接的位置上（第一参数）。
		list<int> d{ 12,13,14,15 };
		a.splice(a.end(), d, d.begin(), d.end());
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
	void test2() {
		list<int> a{ 0,1,2,3,4,5,5 };
		//第一参数为 val
		//从容器中删除所有等于第一参数的元素。
		a.remove(5);

		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
	void test3() {
		list<int> a{ 0,1,2,3,4,5 };
		auto pre = [](const int& a) {
			return a > 3;
		};
		//第一参数为 Predicate  
		a.remove_if(pre);

		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
	void test4() {
		list<int> a{ 0,1,2,3,4,5,5 };
		//unique 分为有参与无参两个方式
		//无参时，从容器中每个相等元素的连续组中除去除第一个元素外的所有元素。
		//注意，只有与列表容器紧邻的元素相比，该元素才从列表容器中删除。
		a.unique();
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		//有参时，从容器中除去除第一个元素外的其他符合条件的所有元素。
		auto binary_pre = [](const int& a, const int& b) {
			return (fabs(a - b) < 5);
		};
		list<int> b{ 1,2,3,4,5,6,10,15 };
		b.unique(binary_pre);

		cout << "b 中的元素：";
		for (auto& t : b) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
	void test5() {
		list<int> a{ 0,1,2,3,4,5 };
		list<int> b{ 1,2,3,4,5,6 };
		//merge 的前提是两个有序 list
		//第一种直接合并
		a.merge(b);
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		//第二种设置条件
		list<double> c{ 1.4,2.2,2.9,3.1,3.7,7.1 };
		list<double> d{ 2.1 };
		auto cmp = [](const double& a, const double& b) {
			return (int(a) < int(b));
		};
		c.merge(d, cmp);

		cout << "c 中的元素：";
		for (auto& t : c) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
	void test6() {
		list<int> a{ 0,1,2,3,4,5 };
		auto cmp = [](const int& a, const int& b) {
			return a > b;
		};
		//支持有参和无参两种方式
		//a.sort()  或 a.sort(Compare)
		a.sort(cmp);
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;

		a.sort();
		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
	void test7() {
		list<int> a{ 0,1,2,3,4,5 };
		a.reverse();

		cout << "a 中的元素：";
		for (auto& t : a) {
			cout << t << " ";
		}
		cout << endl;
		cout << endl;
	}
};
int main() {
	MYTEST a;

	a.test1();
	a.test2();
	a.test3();
	a.test4(); 
	a.test5();
	a.test6();
	a.test7();

	return 0;
}
输出：
a 中的元素：0 1 2 3 4 5 6 7 8 9 10
a 中的元素：0 1 2 3 4 5 6 7 8 9 10 11
a 中的元素：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

a 中的元素：0 1 2 3 4

a 中的元素：0 1 2 3

a 中的元素：0 1 2 3 4 5
b 中的元素：1 6 15

a 中的元素：0 1 1 2 2 3 3 4 4 5 5 6
c 中的元素：1.4 2.2 2.9 2.1 3.1 3.7 7.1

a 中的元素：5 4 3 2 1 0
a 中的元素：0 1 2 3 4 5

a 中的元素：5 4 3 2 1 0
JustWei_
关注
专栏目录
C++ STL ForwardList使用方法
qq_44800780的博客
12-17 344
结构 头文件 <forward_list> ForwardList的能力 和list相比，凡是list没有的功能，它也没有.是一个单向的，不能走回头路 优点: 内存用量较少，行动也比较快速 缺点: 1.只提供前向迭代器，不支持反向迭代器 2.不提供成员函数size() 3.没有指向最末元素的锚点，没有back()、push_back()、pop_back() ForwardList的...
C++ STL容器 —— forward_list 用法详解
Ember_Sky
04-28 1479
C++ STL容器—— forward_list 成员函数用法详解 写在前面：近期正在重新学习C++的STL容器，因此准备将STL函数的用法详细记录一下，主要介绍一些基本成员函数的用法, 外加实际的例子，并不涉及原理。其实了解这些函数最好的方法还是需要自己上手操作一下. 写的不好, 请大神手下留情. 下面说的 “运行之后” 表示: 运行上个语句之后的结果. 一行如果说的太长的话, 就得拖动下面...
特殊的forward_list操作
weixin_33935505的博客
08-15 123
为了理解forward_list为什么有特殊版本的添加和删除操作，考虑当我们从一个单向链表中删除一个元素时会发生什么。当添加或删除一个元素时，删除或添加的元素之前的那个元素的后继会发生变化。为了添加或删除一个元素，我们需要访问其前驱，以便改变前驱改变前驱的链接。但是，forward_list是单向链表。在一个单向链表中，没有简单的方法来获取一个元素的前驱，出于这个原因，在一个forward_lis...
C++必修：STL之forward_list与list的使用
最新发布
Bettysweetyaaa的博客
08-09 1049
这篇文章聚焦 C++ 中的 `forward_list` 和 `list` 容器。详解其特点，如内存高效利用、擅长特定操作等。还涵盖初始化、容量操作、访问与修改等多方面。助您深入了解，提升编程技能，不容错过！
C++中容易忘的知识点——list和forward_list（四）
Livalueur
10-04 1万+
list容器 list的特点 list的初始化和成员函数 forward_list容器 forward_list的特点 forward_list的初始化和成员函数
C++ STL之list、forward_list
SJLin
08-14 1163
一. 简介 list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的。 list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的。 list的实现大概是这样的：list的每个节点有三个域：前驱元素指针域、数据域和后继元素指针域。 前驱元素指针域保存了前驱元素的首地址...
C++利用std::forward_list查找插入数据方法示例
08-29
在C++编程中，std::forward_list是一种单向链表容器，它在C++11标准库中被引入。forward_list的设计目标是为了提供一种高效、节省内存的序列容器，尤其适用于需要频繁插入和删除元素，但不需要快速随机访问的情况。...
【STL】顺序容器之list、forward_list用法总结
WYuan的博客
12-15 1494
        一、基本原理         list是双向链表，forward_list是单向链表，在链表的任何位置添加或删除元素都很快，但是作为代价，这两个容器都不支持随机访问，为了访问容器中的某一个元素，我们只能遍历整个容器。        forward_list是C++新标准增加的类型，其设计目标是达到与最好的手写单向链表数据结构相当的性能，因此forward_list没有siz
forward_list
weixin_43117602的博客
02-07 1665
forward_list 容器具有和 list 容器相同的特性，即擅长在序列的任何位置进行插入元素或删除元素的操作，但对于访问存储的元素，没有其它容器（如 array、vector）的效率高。 另外，由于单链表没有双向链表那样灵活，因此相比 list 容器，forward_list 容器的功能受到了很多限制。比如，由于单链表只能从前向后遍历，而不支持反向遍历，因此 forward_list 容器只提供前向迭代器，而不是双向迭代器。这意味着，forward_list 容器不具有 rbegin()、rend()
C++11标准库(STL)使用总结——forward_list
程序猿之家
09-10 4362
forward_list（单向链表）是序列容器，允许在序列中的任何地方进行恒定的时间插入和擦除操作。 forward_list（单向链表）被实现为单链表; 单链表可以将它们包含的每个元素存储在不同和不相关的存储位置中。通过关联到序列中下一个元素的链接的每个元素来保留排序。forward_list容器和列表 之间的主要设计区别容器是第一个内部只保留一个到下一个元素的链接，而后者每个元素保留两个链接：...
forward_list源码分析
愤怒的弱鸡
08-18 469
forward_list是一个单链表的实现，相较于list，其有更高的空间存储效率，但是其迭代器只能进行单向移动。 其构造如图所示： 与list进行比较可以发现，其头部节点不再存储任何数据并且结构体中也没有开辟空间来存储forward_list的大小，所以其并没有实现size()这个成员函数，即我们无法在O(1)的时间内获取forward_list大小。 其尾部节点并没有指向头部节点，其指向的为nullptr，这样做能有效保证其迭代器的单向性。 _Fwd_list_node _Fwd_list_node继
STL::forward_list之前向链表
devourHeavens的专栏
04-25 5923
本文是Devour Heavens撰写整理的关于C++标准库的知识，所有资料均来自于C++官方文档，欢迎转载。但是为了尊重原作者的劳动，请注明出处！谢谢！ class template forward_list template > class forward_list; Forward list 前向链表是序列容器，使固定时间插入和擦除操作序列内的任何地方。 前向链表的
STL容器-- forward_list 用法
weixin_30799995的博客
01-30 76
http://www.cplusplus.com/reference/forward_list/ 转载于:https://www.cnblogs.com/icmzn/p/8386077.html
STL常用操作：forward_list
zhuikefeng的博客
03-06 246
1.初始化 forward_list<int> f_lst1; //空forward_list forward_list<int> f_lst2(3,77); //初始化3个77的forward_list forward_list<int> f_lst3(f_lst2.begin(), f_ls...
forward_list学习之操作sort，merge， splice， remove， remove_if， reverse， unique
chenyijun的专栏
03-22 328
本篇学习forward_list的操作 sort：对元素进行排序 merge：合并二个已排序列表 splice_after：从另一 forward_list 移动元素 remove：移除满足特定标准的元素 remove_if：移除满足特定标准的元素 reverse：将该链表的所有元素的顺序反转 unique：删除连续的重复元素
STL（六）forward_list 单向链表
程序猿的视界
11-30 2964
参考： http://blog.csdn.net/devourheavens/article/details/7497172 http://zh.cppreference.com/w/cpp/container/forward_list forward_list template > class forward_list; Forward list      
C++容器之forward_list
tj807126663的专栏
06-03 5020
简介          Forward_list是一种能在常数时间内在任何位置插入和删除的顺序容器。Forward_list是单向链表。          Forward_list和list的区别在于前者是单向链表，在内部元素只有一个链接到下一个元素，它的迭代器是前向有效的；后者是双向链表，在内部存在两个链接，一个链接指向下一个元素，另一个链接指向前面一个元素，它的迭代器是双向有效地，在存储方
ABAP Write 宝典
热门推荐
少年休闲海
02-05 1万+
列表是ABAP/4报表程序数据的输出媒介。每个ABAP/4报表程序将其输出数据传递到直接与该程序连接的列表中。每个程序最多生成21个列表：1个基本列表和20个辅助列表。    将数据写入列表的基本ABAP/4语句是WRITE、SKIP和ULINE输出语句。 一、标准列表结构 （1）标准页眉：标准页眉至少包括两行标准标题。标准标题的首行包含列表表头和页号。第二行由水平线组成。执行程序时，列表表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值