飞道的博客

C++— list 使用—详解

2021-04-25 22:28 248人阅读  评论(0)

本章目录

1. list 的介绍及使用

1.1 list 的介绍

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  3. list 与forward_list非常相似：主要的不同在于forword_list是单链表，只能朝前迭代。
  4. 与其他的序列是容器相比（array，vector，deque）list 通常在任意位置进行插入、移除元素的效率更高。
  5. 与其他序列是容器相比，list 和 forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list 的第6个元素，必须从已知位置（比如头部或者尾部）迭代到该位置，在这段位置上迭代需要线性的时间开销；list 还需要一些额外的空间，以保存每个结点的相关信息。

1.2 list 的使用

list 中的接口比较多，只需掌握如何正确使用，然后再去深入研究背后的原理，从而达到拓展的能力。以下为list中一些常见的重要接口。

1.2.1 list 的构造函数

构造函数（constructor） 接口说明
list ( ) 构造空的list
list (size_type n,const value_type& val=value_type()) 构造的list中包含n个值为val的元素
list(const list& x) 拷贝构造函数
list(Inputlterator first , Inputlterator last) 用 [first,last) 区间的元素构造list

【注意】：这里的区间是左闭右开
list 的构造函数使用范例

#include<iostream>
#include<list>

int main()
{
   
	std::list<int> l1;                           //构造一个空的l1
	std::list<int> l2(4, 100);                   //l2中放4个值为100的元素

	std::list<int> l3 (l2.begin(), l2.end());    //用l2的[begin(),end())左闭右开的区间构造l3
	std::list<int> l4(l3);                       //用l3拷贝构造l4

	//以数组为迭代器区间构造15
	int array[] = {
    67, 34, 78, 98, 90 };
	std::list<int>l5(array, array + sizeof(array) / sizeof(int));

	//用迭代器方式打印l5中的元素
	for (std::list<int>::iterator it = l5.begin(); it != l5.end(); it++)
		std::cout << *it << " ";
	std::cout << std::endl;

	//C++11范围for的方式遍历
	for (auto& e : l5)
		std::cout << e << " ";

	std::cout << std::endl;
	return 0;

}

1.2.2 list iterator 的使用

此处，可以暂时将迭代器理解成一个指针，该指针指向list中的某一个节点。

函数声明 接口说明
begin + end 返回第一个元素的迭代器 + 返回最后一个元素下一个位置的迭代器
rbegin + rend 返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator，即begin的位置

【注意】：（1）begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动。
（2）rbegin与rend为反向迭代器，对迭代器执行++操作，迭代器向前移动。
list iterator 使用范例

#include<iostream>
using namespace std;
#include<list>

void print_list(const list<int>& l)
{
   
	//注意这里调用的是list的 begin()const,返回list的const_iterator对象
	for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
	{
   
		cout << *it << " ";
		// *it=10;编译不通过
	}
	cout << endl;
}

int main()
{
   
	int array[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int>l(array, array + sizeof(array) / sizeof(array[0]));
	//使用正向迭代器正向list中的元素
	for (list<int>::iterator it = l.begin(); it != l.end(); ++it)
		cout << *it << " ";
	cout << endl;

	//使用反向迭代器逆向打印list中的元素
	for (list<int>::reverse_iterator it = l.rbegin(); it != l.rend(); ++it)
		cout << *it << " ";
	cout << endl;
	return 0;
}

1.2.3 list capacity

函数声明 接口说明
empty 检测list是否为空，是返回true，否则返回false
size 返回list中有效结点的个数

1.2.4 list element access

函数声明 接口说明
front 返回list的第一个节点值中的引用
back 返回list的最后一个节点中值的引用

1.2.5 list modifiers

函数声明 接口说明
push front 在list 首元素位置插入值为val的元素
pop front 删除list 中的第一个元素
push back 在list 尾部插入val元素
pop back 删除list中最后一个元素
insert 在list position 位置中插入值为val的元素，返回当前节点的下一个节点的迭代器
swap 交换两个list中的元素
clear 清空list中的有效元素
unique 删除list中连续相同部分，只保存一个
splice 拼接，将元素拼接过去，可以指定位置

以上函数使用范例：

#include<iostream>
#include<list>
#include<vector>
using namespace std;

void PrintList(list<int>& l)
{
   
	for (auto& e : l)
		cout << e << " ";
	cout << endl;
}

// push_back/pop_back/push_front/pop_front
void TestList()
{
   
	int array[] = {
    1, 2, 3 };
	list<int>L(array, array + sizeof(array) / sizeof(array[0]));

	//在list的尾部插入4，头部插入零0
	L.push_back(4);
	L.push_front(0);

	//删除list尾部节点和头部节点
	L.pop_back();
	L.pop_front();
	PrintList(L);
}

// insert/erase
void TestList2()
{
   
	int array[] = {
    1, 2, 3 };
	list<int>L(array, array + sizeof(array) / sizeof(array[0]));
     
	//获取链表中的第二个节点
	auto pos = ++L.begin();
	cout << *pos << endl;

	//在pos前插入值为4的元素
	L.insert(pos, 4);
	PrintList(L);

	//在pos前插入5个值为5的元素
	L.insert(pos, 5, 5);
	PrintList(L);

	//在pos前插入[v.begin(),v.end)区间中的元素
	vector<int>v{
    7, 8, 9 };
	L.insert(pos, v.begin(), v.end());
	PrintList(L);

	//删除pos位置上的元素
	L.erase(pos);
	PrintList(L);

	//删除list中[begin，end)区间中的元素，即删除list中的所有元素
	L.erase(L.begin(), L.end());
	PrintList(L);
}

//resize/swap/clear
void TestList3()
{
   
	//用数组来构造list
	int array[] = {
    1, 2, 3 };
	list<int>l1(array, array + sizeof(array) / sizeof(int));
	PrintList(l1);

	//交换l1和l2中的元素
	int array2[] = {
    4, 5, 6 };
	list<int>l2(array2, array2 + sizeof(array2) / sizeof(int));
	l1.swap(l2);
	PrintList(l1);
	PrintList(l2);

	//将l2中的元素清空
	l2.clear();
	cout << l2.size() << endl;
}

int main()
{
   
	TestList();
	TestList2();
	TestList3();
	return 0;
}

list中还有一些操作，需要用到时大家参阅list的文档说明。

1.2.6 list 的迭代器失效

前面说，此处大家可以将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指接点失效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因为在list中进行插入时是不会导致list的迭代器失效的，只有删除时才会失效，并且失效的只是只想被删除节点的迭代器，其他迭代器不会受影响。

void TestListIterator1()
{
   
	int array[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array + sizeof(array) / sizeof(int));

	auto it = l.begin();
	while (it != l.end)
	{
   
		//l.erase(it);
		//++it;
		//erase()函数执行以后，it所指向的节点已经被删除，因此it无效，在下一次使用it时，必须先给其赋值
		//正确用法应该是：
		l.erase(it++);

		//或者
		it = l.erase(it);
	}
}

2. list 的模拟实现

要模拟实现list,比喻要熟悉list的底层结构及其接口的含义，通过上面的学习，这些内容我们已经基本掌握，现在我们要模拟实现list.

#include<iostream>
#include<list>
#include<functional>
using namespace std;

namespace myspace
{
   
	template<class _Ty>
	class list;

	template<class _Ty>
	class ListIterator;

	//节点类
	template<class _Ty>
	class ListNode
	{
   
		friend class list<_Ty>;
		friend class ListIterator<_Ty>;
	public:
		ListNode() :_Value(_Ty()), _Next(nullptr), _Prev(nullptr)
		{
   }
		ListNode(_Ty V, ListNode* next = nullptr, ListNode *prev = nullptr) :_Value(V), _Next(next), _Prev(prev)
		{
   }
	private:
		_Ty           _Value;
		ListNode      *_Next;
		ListNode      *_Prev;
	};

	//迭代器
	template<class _Ty>
	class ListIterator
	{
   
		typedef ListIterator<_Ty> _It;
	public:
		ListIterator() :Ptr(nullptr)
		{
   }
		ListIterator(ListNode<_Ty>*_P) :_Ptr(_P)
		{
   }
	public:
		_It& operator++()
		{
   
			_Ptr = _Ptr->_Next;
			return *this;
		}
		_It& operator--()
		{
   
			_Ptr = _Ptr->Prev;
			return *this;
		}
		_Ty& operator*()
		{
   
			return (_Ptr->_Value);
		}
		bool operator!=(const _It &it)
		{
   
			return _Ptr != it._Ptr;
		}
		bool operator==(const _It &it)
		{
   
			return _Ptr == it._Ptr;
		}
		ListNode<_Ty>* _Mynode()
		{
   
			return _Ptr;
		}
	private:
		ListNode<_Ty> *_Ptr;
	};

	//链表类
	template<class _Ty>
	class list
	{
   
	public:
		typedef ListNode<_Ty>* _Nodeptr;
		typedef ListIterator<_Ty> iterator;
	public:
		list() :_Size(0)
		{
   
			CreateHead();
		}
		list(size_t n, const _Ty &x = _Ty()) :_Size(0)
		{
   
			CreateHead(),
			insert(begin(), n, x);
		}
		list(const _Ty *first, const _Ty *last) :_Size(0)
		{
   
			CreateHead();
			while (first != last)
				push_back(*first++);
		}
		list(iterator first, iterator last)
		{
   
			CreateHead();
			while (first != last)
			{
   
				push_back(*first);
				++first;
			}
		}
		list(list<_Ty>&lt) :_Size(0)
		{
   
			CreateHead();
			list<_Ty>tmp(lt.begin(), lt.end());
			this->swap(tmp);
		}
		~list()
		{
   
			clear();
			delete _Head;
			_Size = 0;
		}
	public:
		void push_back(const _Ty &x)
		{
   
			insert(end(), x);
		}
		void pop_back()
		{
   
			erase(--end());
		}
		void push_front(const _Ty &x)
		{
   
			insert(begin(), x);
		}
		void pop_front()
		{
   
			erase(begin());
		}
		_Ty& front()
		{
   
			return *begin();
		}
		const _Ty& front()const
		{
   
			return *begin();
		}
		_Ty& back()
		{
   
			return *--end();
		}
		const _Ty& back()const
		{
   
			return *--end();
		}
	public:
		size_t size()const
		{
   
			return _Size;
		}
		bool empty()const
		{
   
			return (size() == 0);
		}
	public:
		iterator begin()
		{
   
			return iterator(_Head->_Next);
		}
		iterator end()
		{
   
			return iterator(_Head);
		}
		void clear()
		{
   
			erase(begin(), end());
		}
	public:
	    //在_P位置前插入值为x的节点
		iterator insert(iterator _P, const _Ty &x)
		{
   
			_Nodeptr cur = _P._Mynode();
			_Nodeptr _S = new ListNode<_Ty>(x);

			_S->_Next = cur;
			_S->_Prev = cur->_Prev;
			_S->_Prev->_Next = _S;
			_S->_Next->_Prev = _S;

			_Size++;
			return iterator(_S);
		}
		void insert(iterator _P, size_t n, const _Ty &x = _Ty())
		{
   
			while (n--)
				insert(_P, x);
		}
		//删除_P位置的节点，返回该节点的下一个节点位置
		iterator erase(iterator _P)
		{
   
			_Nodeptr cur = _P._Mynode();
			_Nodeptr next_node = cur->_Next;

			cur->_Prev->_Next = cur->_Next;
			cur->_Next->_Prev = cur->_Prev;
			delete cur;

			_Size--;

			return iterator(next_node);
		}
		iterator erase(iterator first, iterator last)
		{
   
			while (first != last)
			{
   
				first = erase(first);
			}
			return first;
		}
		void swap(list<_Ty> &lt)
		{
   
			std::swap(_Head, lt._Head);
			std::swap(_Size, lt._Size);
		}
	protected:
		void CreateHead()
		{
   
			_Head = new ListNode<_Ty>;
			_Head->_Prev = _Head->_Next = _Head;
		}
	private:
		_Nodeptr       _Head;
		size_t         _Size;

	};
};

void main()
{
   
	int arr[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	myspace::list<int>lt(arr, arr + 5);
	myspace::list<int>lt1(lt);

	myspace::list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
   
		cout << *it << " ";
		++it;
	}
	cout << endl;

	myspace::list<int>::iterator it1 = lt1.begin();
	while (it1 != lt1.end())
	{
   
		cout << *it1 << " ";
		++it1;
	}
	cout << endl;

}

转载：https://blog.csdn.net/weixin_45796387/article/details/116096112
查看评论
* 以上用户言论只代表其个人观点，不代表本网站的观点或立场