list的介绍

1：list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2：与其他序列容器相比（array,vector,deque），list通常可以在任意位置进行插入，移除等效率更高。
3：与其他序列式容器相比,list和forward_list最大的缺陷就是不支持任意位置的访问，比如：要访问list的第6个元素，必须从已知的位置的位置迭代到目标位置，然而，迭代的时间复杂度通常为线性开销，list还需要一些额外的空间，来保存每个结点的相关联信息（对于存储类型较小的list来说)。

list的使用

list的定义方法

方法一：

list<int> lt;
1

方法二：
构造1个2类型为list 容器。

list<int> lt1(1,2);
1

方法三：
拷贝构造类型为list 的lt1。

list<int> lt2( lt1);
1

方法四：
利用迭代器区间进行构造。

string s("hello c++");
list<char>lt3(s.begin(),s.end());

1
2
3

方法五：
也是迭代器区间构造的一种形式，区间为左闭右开。

int arr[] = { 1,2,3,4,5 };
int sz = sizeof(arr) / sizeof(int);

list<int> lt1(arr, arr + 2);
1
2
3
4
5

list迭代器失效问题

void Test1()
{
 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 list<int> l(array, array+sizeof(array)/sizeof(array[0]));
 auto it = l.begin();
 while (it != l.end())
 {
 // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给
其赋值
 l.erase(it); 
 ++it;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

list插入和删除

insert

三种插入方式：
方式1：
在指定位置前插入一个数。
方式2：
在指定位置插入n个数。
方式3：
在指定位置插入相同容器而理性的迭代器区间数据（左闭右开）

int main()
{

list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
list<int>::iterator pos = find(lt.begin(), lt.end(),3 );
lt.insert(pos, 0); 
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; 
pos = find(lt.begin(), lt.end(), 3);
lt.insert(pos, 2, 1); //
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; 
vector<int> v(3, 8);
pos = find(lt.begin(), lt.end(), 1);
lt.insert(pos, v.begin(), v.end());
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; 

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

erase

三种删除方式：
方式1：
指定目标位置进行删除。
方式2：
指定迭代器区间进行删除。

int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
lt.push_back(6);
auto pos = find(lt.begin(), lt.end(), 2);
lt.erase(pos); //删除2位置的结点。
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; 
pos = find(lt.begin(), lt.end(), 3);
lt.erase(pos, lt.end()); //给定迭代器区间删除3后面的结点。
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; 
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

list迭代器的使用

正向迭代器和反向迭代器的位置是对称的，指向的位置相反。

begin，end 和 rbegin，rend

int main()
{
list<int> lt{ 1,2,3,4,5 };
//正向迭代器遍历容器
auto it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
it++;
}
cout << endl;

auto  rit = lt.rbegin();
while( rit != lt.rend() )
{
cout << *rit << " ";
rit++;
}

return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

list元素访问

由于list和forward_lsit一样都不能随机访问，STL中具有获取list首尾元素功能。

front 和 back

int main()
{
list<int> lt;
lt.push_back(0);
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
lt.push_back(6);
cout << lt.front() << endl;     //获取list首元素
cout << lt.back() << endl;      //获取list尾元素
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

list容量控制与数据清理

resize

1: 如果所给的第一个值大于lsit当前的size，如果给了第二个值，那么多出的size的值就为第二个所给值，如果没给，编译器就主动调用缺省值（一般为0）。
2：如果所给的值小于list当前的size，则lsit当前的size就为这个所给值

int main()
{
list<int> lt{ 1,2,23 };
for (auto e : lt)
{
cout << e << " ";
}
lt.resize(7, 6); //多出的size初始值都为6；
cout << endl;
for (auto e : lt)
{
cout << e << " ";
}
lt.resize(1);      //list当前只剩下一个size；
cout << endl;
for (auto e : lt)
{
cout << e << " ";
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

clear

clear用于清空list容器，此时list的size为0；

int main()
{
list<int> lt(3, 2);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; 
cout << lt.size() << endl; 
lt.clear(); 
for (auto e : lt)
{
cout << e << " ";
}
cout << endl;

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

list操作函数

splice

list中splice函数用于两个list容器之间的拼接，有三种常见拼接方法。
1： 将指定容器全部数据拼接到指定位置。
2： 将指定容器的某个数据拼接到目标容器的指定位置。
3： 将指定容器的某个迭代器区间（左闭右开）数据拼接到目标容器中。

int main()
{
list<int> lt1(1, 1);
list<int> lt2(1, 2);
//将lt2拼接到lt1首部。
lt1.splice(lt1.begin(), lt2); 
for (auto& e : lt1)
{
cout << e << " ";
}
cout << endl; 
list<int> lt3(1, 3);
list<int> lt4(1, 4);

//将lt4容器中首位置拼接到目标容器lt3的尾部。
lt3.splice(lt3.end(), lt4, lt4.begin()); 
    for(auto&e : lt3)
{
cout << e << " ";
}
cout << endl;

list<int> lt5(1, 5);
list<int> lt6(1, 6);
//将指定容器lt6的指定迭代器区间内的数据拼接到目标容器lt5的首部
lt5.splice(lt5.begin(), lt6, lt6.begin(), lt6.end()); 
for (auto& e : lt5)
{
cout << e << " ";
}
cout << endl;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

remove 和 remove_if

remove:
删除容器容器中指定的数据。（包括重复项）
remove_if
删除容器当中符合条件的数据。

bool test(const int& val)
{
//删除中容器小于3的数。
    return val < 3;

}
int main()
{
list<int> lt1{ 1,2,3,4,5 };
lt1.remove_if(test);              
for (auto& e : lt1)
{
cout << e << " ";
}
list<int> lt2{ 1,2,3,4,5,6 };
//删除list容器中指定元素。
lt2.remove(3); 
for (auto& e : lt2)
{
cout << e << " ";
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

unique

删除容器中连续的重复元素。
注意：
在使用unique去重之前最好先让list排序。

int main()
{
list<int> lt1{ 3,1,1,2,3,3,4,5 };
//在使用unique之前最好先使用sort排序一下。
lt1.sort();
lt1.unique();
for (auto& e : lt1)
{
cout << e << " ";
}
}
1
2
3
4
5
6
7
8
9
10
11

merge

将指定容器合并到目标容器中，并且合并过后的容器lt1依然为升序（类似于归并排序）

int main()
{
list<int> lt1{ 3,1,1,2,3,3,4,5 };
//在使用unique之前最好先使用sort排序一下。
list<int> lt2{ 6,7,8 };
lt1.sort();
//将lt2有序容器合并到lt1中。
lt1.merge(lt2);
for (auto& e : lt1)
{
cout << e << " ";
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

reverse

将容器中所有数据的位置进行逆置。

int main()
{
list<int> lt1{ 1,2,3 };
lt1.reverse();
for (auto& e : lt1)
{
cout << e << " ";
}
}
1
2
3
4
5
6
7
8
9

assign

1：将指定个数指定内容的分配给容器（覆盖分配）；
2：利用迭代器，将存储相同数据类型的容器，指定迭代器区间进行分配。

int main()
{
list<int> lt1{ 1,2,3 };
lt1.assign(3, 1);
for (auto& e : lt1)
{
cout << e << " ";
}
string s("hello C++");
list<char>lt2;
lt2.assign(s.begin(), s.end());

for (auto& e : lt2)
{
cout << e << " ";
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17