[C++初阶]list类的初步理解

一、标准库的list类

list的底层是一个带哨兵位的双向循环链表结构
对比forward_list的单链表结构，list的迭代器是一个双向迭代器
与vector等顺序结构的容器相比，list在任意位置进行插入删除的效率更好，但是不支持任意位置的随机访问
list是一个模板类，在使用的时候我们需要给出元素的类型

使用list类时，需要包含头文件<list>

二、list类的常用接口

1.常用的构造函数

1.默认构造函数，构造一个空的链表

list();

例如：

void test()
{
	list<int> lt;
}

2.构造一个list对象并用n个val初始化

list(size_type n, const value_type& val =  value_type());

例如：

void test()
{
	list<int> lt(3, 1);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

运行结果：

3.list类的拷贝构造函数

list(const list& x); 

例如：

void test()
{
	list<int> lt(3, 1);
	list<int> lt1(lt);
	for (auto i : lt1)
	{
		cout << i << " ";
	}
}

运行结果：

4.使用迭代器的初始化构造

Template<class InputIterator>

list(InputIterator first, InputIterator last);

例如：

void test()
{
	list<int> lt(3, 1);
	list<int> lt1(lt.begin(), lt.end());
	for (auto i : lt1)
	{
		cout << i << " ";
	}
}

运行结果：

2.常用的容量接口

还是老几样，我这里一块讲一讲吧。

1.size,empty,max_size,resize

size:返回链表容器中的元素数。

size_type size() const;

empty:返回列表容器是否为空（即其大小是否为 0）。
（注意：此函数不会以任何方式修改容器。若要清除链表容器的内容，请参阅 list::clear。）

bool empty() const;

max_size（不常用）:返回链表容器可以容纳的最大元素数。
（由于已知的系统或库实现限制，这是容器可以达到的最大潜在大小，但绝不能保证容器能够达到该大小：在达到该大小之前，它仍然可能无法在任何时候分配存储。）

size_type max_size() const;

resize:调整容器的大小，使其包含 n 个元素。
如果 n 小于当前容器大小，则内容将减少到其前 n 个元素，删除超出（并销毁它们）的元素。
如果 n 大于当前容器大小，则通过在末尾插入所需数量的元素来扩展内容，以达到 n 的大小。如果指定了 val，则新元素将初始化为 val 的副本，否则，它们将进行值初始化。
(请注意，此函数通过插入或擦除容器中的元素来更改容器的实际内容。)

void resize (size_type n, value_type val = value_type());

例如：

​
void test()
{
	list<int> lt(3, 1);
	/*list<int> lt1(lt);*/
	list<int> lt1(lt.begin(), lt.end());
	list<int> lt2;
	cout << lt1.size() <<endl;
	cout << lt1.empty() <<endl;
	cout << lt2.empty() <<endl;
	lt1.resize(10);
	cout << lt1.size() << endl;
	for (auto i : lt1)
	{
		cout << i << " ";
	}
}

​

运行结果:

3. 常用的访问与遍历

1.迭代器

iterator begin();

const_iterator begin() const;

iterator end();

const_iterator end() const;

迭代器:用于获取链表中第一个节点的位置和最后一个节点的下一个位置（即哨兵位）

例如：

void test()
{
	list<int> lt(5, 2);
	list<int> ::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
}

运行结果:

2.反向迭代器

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

reverse_iterator rend();

const_reverse_iterator rend() const;

反向迭代器，rbegin获取容器中最后一个节点的位置，rend获取容器中哨兵位的位置

void test()
{
	list<int> lt = { 1,23,4,4,5,2 };
	list<int> ::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << " ";
		++rit;
	}
}

运行结果:

注意:反向迭代器rit也要用++而不是--

3.front和back

front:

reference front();

const_reference front() const;

返回链表中第一个节点存储的数据的引用

back:

reference back();

const_reference back() const;

返回链表中最后一个节点存储的数据的引用

例如：

void test()
{
	list<int> lt = {213123,123,34524,213};
	cout << lt.front() << endl;
	cout << lt.back() << endl;

}

运行结果:

4.list的增删查改

1）push_front和pop_front

push_front叫头插,从链表头部插入一个元素

void push_front(const value_type& val);

pop_front叫头删,从链表头部删除一个元素

void pop_front();

void pop_front();

例如:

void test()
{
	list<int> lt = {213123,123,34524,213};
	cout << lt.front() << endl;
	lt.push_front(21345);
	cout << lt.front() << endl;
	lt.pop_front();
	cout << lt.front() << endl;
}

运行结果:

2) push_back和pop_back

push_back叫尾插,从链表尾部插入一个元素

void push_back(const value_type& val);

pop_back叫尾删,从链表尾部删除一个元素

void pop_back();

例如:

void test()
{
	list<int> lt = {213123,123,34524,213};
	cout << lt.back() << endl;
	lt.push_back(21345);
	cout << lt.back() << endl;
	lt.pop_back();
	cout << lt.back() << endl;
}

运行结果:

3) find

template <class InputIterator, class T>

InputIterator find(InputIterator first, InputIterator last, const T& val);

在两个迭代器区间寻找val并返回其所在处的迭代器

例如：

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 1);
	*pos = 114514;
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

运行结果:

注意:该函数并非list的成员函数，是标准库中的函数，多个容器共用该find函数

可以看到，我们可以直接对list的迭代器进行解引用并修改其内容，但是迭代器不应该指向节点吗？为什么对其解引用能修改数据呢？

实际上list的迭代器并不是用原生态指针进行模拟实现的，需要进行底层的封装，这里会在list的模拟实现的源代码中体现。

4）insert

iterator insert(iterator position, const value_type& val);

void insert(iterator position, size_type n, const value_type& val);

————————————————————————————————————————

template<class InputIterator>

void insert(iterator position, InputIterator first, InputIterator last);

在position位置的前面插入一个或多个元素

例如：

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 1);
	lt.insert(pos, 8848);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

运行结果:

细心的同学可能已经发现了，list的insert操作是不会导致迭代器失效的，因为pos指向的节点不变，相对位置也不变。

但是list的删除操作一定会导致迭代器失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

5) erase

iterator erase(iterator position);

iterator erase(iterator first, iterator last);

删除position位置的元素或者 [first，last) 区间的所有元素

例如：

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 1);
	lt.erase(lt.begin());
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

运行结果:

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 2);
	lt.erase(lt.begin(),pos);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

运行结果:

6) swap

void swap(vector& x);

交换两个list对象

例如：

void test()
{
	list<int> lt;
	list<int> lt2(6, 12);
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	lt.swap(lt2);
	for (auto i : lt2)
	{
		cout << i << " ";
	}
	cout << endl;
}

运行结果:

7）assign

template <class InputIterator>

void assign(InputIterator first, InputIterator last);

void assign(size_type n, const value_type& val);

为list指定新内容，替换其当前内容并修改节点个数

例如：

void test()
{
	list<int> lt;
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	lt.assign(4, 0);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

运行结果:

8）clear

void clear();

删除链表所有节点

例如：

void test()
{
	list<int> lt;
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	lt.clear();
	cout << lt.size() << endl;
}

运行结果:

5.list的顺序修改接口

(1）sort

void sort();

template<class Compare>

void sort(Compare comp);

list由于结构的特殊性，是无法使用标准库中的sort函数的，因为迭代器无法进行相减的操作

并且在C++文档中，我们可以看到标准库中的sort也限定了迭代器的类型必须是可以进行随机访问（RandomAccess）的

default (1)	
template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);
custom (2)	
template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

迭代器有几个功能分类：

• 单向迭代器，只能进行++
• 双向迭代器，可以++和--
• 随机迭代器，可以++，--，+和-

但是list的sort函数也是没什么必要的，因为直接对链表排序的效率比拷贝到vector进行排序再拷贝回链表要慢的多。

(2）reverse

template <class BidirectionalIterator>
  void reverse (BidirectionalIterator first, BidirectionalIterator last);

对链表进行逆置

例如：

void test()
{
	list<int> lt;
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	for (auto i : lt)
	{
		cout << i << " ";
	}
	cout << endl;
	lt.reverse();
	for (auto i : lt)
	{
		cout << i << " ";
	}
	cout << endl;

}

运行结果:

---

如有错误,欢迎指正。