• C++：stl_List的介绍与模拟实现

    目录

    一.List定义

    二.List的使用

    （1）push_back后的遍历

    ​编辑

    （2）erase，insert那些跟vector一样用法，没什么好说的

    （3）sort（List支持排序，但效率低）

    【1】简介 List::sort

    【2】库里面的sort不支持List的原因(三类迭代器)：

    【3】std::sort 与 List::sort 比较，List::sort就是 "飞屋"

    三.List模拟实现

    重点：

    （1）return iterator(_head->_next); 是返回了匿名对象

    （2）begin()迭代器能否直接返回  _head->_next ？——可以

    （3）it->_a1 解释

    （4）为什么list要封装新的iterator，而不能用原生指针？vector却可以

    （5）const迭代器

    （6）erase迭代器失效

    1.第一阶段

    List.h

    Test.cpp

    2.第二阶段 const迭代器

    List.h

    3.第三阶段

    易错点：

    四.list 相关题目

    一.List定义

    Lists are sequence containers that allow constant time insert and erase operations anywhere within the sequence, and iteration in both directions.

    List是一个顺序容器，这个顺序容器允许O(1)的时间复杂度任意插入和删除，还支持双向迭代器。（List底层是双向带头链表）

    二.List的使用

    （1）push_back后的遍历

    List底层是链表，链表空间不连续，就舍弃的[]+下标的遍历方法，通常使用迭代器遍历。

    1. void test_list1()
    2. 	{
    3. 		list<int> lt;
    4. 		lt.push_back(1);
    5. 		lt.push_back(2);
    6. 		lt.push_back(3);
    7. 		lt.push_back(4);
    8.  
    9. 		list<int>::iterator it = lt.begin();
    10. 		while (it != lt.end())        //迭代器遍历
    11. 		{
    12. 			cout << *it << " ";
    13. 			++it;
    14. 		}
    15. 		cout << endl;
    16.     
    17. 		for (auto e : lt)            //范围for遍历
    18. 		{
    19. 			cout << e << " ";
    20. 		}
    21. 		cout << endl;
    22.  
    23. 		//list::reverse_iterator rit = lt.rbegin();
    24. 		auto rit = lt.rbegin();
    25. 		while (rit != lt.rend())
    26. 		{
    27. 			cout << *rit << " ";
    28. 			++rit;
    29. 		}
    30. 		cout << endl;
    31.  
    32. 	}

    （2）erase，insert那些跟vector一样用法，没什么好说的

    （3）sort（List支持排序，但效率低）

    【1】简介 List::sort

    库里面的sort不支持List，所以List要有自己的sort（原因在下面），因为结构问题，List::sort效率很低，vector用 std::sort 排序会很快，不建议用List::sort。

    1. void test_list3()
    2. 	{
    3. 		list<int> lt;
    4. 		lt.push_back(1);
    5. 		lt.push_back(2);
    6. 		lt.push_back(3);
    7. 		lt.push_back(4);
    8. 		lt.push_front(10);
    9. 		lt.push_front(20);
    10. 		lt.push_front(30);
    11. 		lt.push_front(40);
    12.  
    13. 		lt.push_back(1);
    14. 		lt.push_back(1);
    15. 		lt.push_back(1);
    16.  
    17. 		for (auto e : lt)
    18. 		{
    19. 			cout << e << " ";
    20. 		}
    21. 		cout << endl;
    22.  
    23. 		lt.sort();
    24. 		lt.unique();
    25.  
    26. 		for (auto e : lt)
    27. 		{
    28. 			cout << e << " ";
    29. 		}
    30. 		cout << endl;
    31. 	}

    【2】库里面的sort不支持List的原因(三类迭代器)：

    实现结构的角度，迭代器再实际中分为三类:
    1、单向。
    2、双向。
    3、随机。

    随机迭代器属于单向迭代器也属于双向迭代器，即：单向迭代器包含随机迭代器，双向迭代器也包含随机迭代器。

    库里面的sort是随机迭代器

    List是双向迭代器

    双向包含随机，但随机不包含双向，所以std::sort的使用不能包含双向

    【3】std::sort 与 List::sort 比较，List::sort就是 "飞屋"

    std::sort 底层是快排（要包含头文件）

    List::sort 底层是归并排序

     

    总结：短数据情况下（1w个数据以内）List::sort是有价值可以用，大数据就要用vector排序了，连续空间的优势 

    三.List模拟实现

    重点：

    （1）return iterator(_head->_next); 是返回了匿名对象

    iterator()是匿名对象，匿名对象只存在于构造该对象的那行代码，离开构造匿名对象的那行代码后立即调用析构函数。

    ①return iterator(_head->_next); 这一句等价于：②先构造一个iterator类的 it对象，因为不是引用返回，所以需要返回it的临时拷贝，临时拷贝又是it拷贝构造得到的。

    ②iterator it( head-> next);     
        return it;

    对比：②经历了构造对象it，然后拷贝构造一个临时变量；①利用匿名对象优化：把构造匿名对象+拷贝构造临时变量 优化成了 直接构造一个对象并返回。

    1.         iterator begin()
    2. 		{
    3. 			return iterator(_head->_next);    //iterator()是匿名对象，详情看（1）
    4. 			//return _head->_next;
    5. 		}
    6.  
    7. 		iterator end()
    8. 		{
    9. 			return iterator(_head);      //iterator()是匿名对象，详情看（1）
    10. 		}

    （2）begin()迭代器能否直接返回  _head->_next ？——可以

    单参数的构造函数支持隐式类型转换：返回值是iterator，原本是先构造iterator类的对象，再拷贝构造出一个临时变量，通过编译器优化就成了直接构造一个对象并返回。

    1.         iterator begin()
    2. 		{
    3. 			return iterator(_head->_next);    //iterator()是匿名对象，详情看（1）
    4. 			//return _head->_next; //能否直接返回  _head->_next ？——可以,详情看（2）
    5. 		}
    6.

    （3）it->_a1 解释

    cout << (*it)._a1 << "-"<< (*it)._a2 <<" "; 访问AA中的数据是正常操作，也可以指针指向的写法访问 it->_a1 。因为 *it 返回的是 _node->_data ，所以 it-> 返回的是 &_node->_data，按理来说指针指向方式 访问AA数据元素写法应该是 it->->_a1 编译器为了可读性进行优化处理，优化以后，省略了一个->，成为it->_a1。

    1. struct __list_iterator中：
    2.         T& operator*()
    3. 		{
    4. 			return _node->_data;
    5. 		}
    6.  
    7.         T* operator->()
    8. 		{ 
    9. 			//return &(operator*());
    10. 			return &_node->_data;
    11. 		}
    12.  
    13. 	void test_list2()
    14. 	{
    15. 		list lt;
    16. 		lt.push_back(AA(1, 1));
    17. 		lt.push_back(AA(2, 2));
    18. 		lt.push_back(AA(3, 3));
    19. 		lt.push_back(AA(4, 4));
    20.  
    21. 		// 迭代器模拟的是指针行为
    22. 		// int* it  *it
    23. 		// AA*  it  *it  it->
    24. 		list::iterator it = lt.begin();
    25. 		while (it != lt.end())
    26. 		{
    27. 			//cout << (*it)._a1 << "-"<< (*it)._a2 <<" ";
    28. 			cout << it->_a1 << "-" << it->_a2 << " ";    //it->_a1解释，详情见(3)
    29. 			++it;
    30. 		}
    31. 		cout << endl;
    32. 	}

    （4）为什么list要封装新的iterator，而不能用原生指针？vector却可以

    1. template<class T>
    2. 	struct __list_iterator  //详情见（3），list为什么不能用原生指针？因为物理空间不连续
    3. 	{……}

     vector相当于家里有矿的孩子，不用努力，家里给（系统支持原生指针做迭代器的++--等）。

    list 相当于普通家庭，需要自己努力（自己写自定义类型支持迭代器__list_iterator，还要重载运算符）

    两者外表（调用）看起来一模一样，实际底层完全不同

    （5）const迭代器

    为了支持像printf这样形参传的是const对象，正常思路是再复制一遍__list_iterator类，然后全部改成const做成__list_const_iterator类，但是这样复用性不好，不便于维护，所以我们采用模板控制const类型参数：反正是对 operator* 和 -> 返回值的改变，不如直接添加两个模板参数T&和T*，分成const和非const两种模板 。lt对象带const时，就用const_iterator模板；对象是非const时就用iterator模板，就用。调用 lt.begin()时，begin()返回的临时对象类型是const_iterator，则__list_iterator 传入的3个模板类型是const_iterator，

    也就是__list_iterator

    1. 	template<class T, class Ref, class Ptr>
    2. 	struct __list_iterator
    3. 	{
    4. 		// *it
    5. 		Ref operator*()
    6. 		{
    7. 			return _node->_data;
    8. 		}
    9.  
    10. 		Ptr operator->()
    11. 		{ 
    12. 			//return &(operator*());
    13. 			return &_node->_data;
    14. 		}	
    15.         ……
    16.  
    17.     template<class T>
    18. 	class list
    19. 	{
    20. 		typedef list_node Node;
    21. 	public:
    22. 		typedef __list_iterator iterator;
    23. 		typedef __list_iteratorconst T&, const T*> const_iterator;
    24.  
    25. 		const_iterator begin() const
    26. 		{
    27. 			// list_node*
    28. 			return const_iterator(_head->_next);
    29. 		}
    30.  
    31. 		const_iterator end() const
    32. 		{
    33. 			return const_iterator(_head);
    34. 		}
    35.     ……
    36.  
    37. 	void print_list(const list<int>& lt)
    38. 	{
    39. 		list<int>::const_iterator it = lt.begin();
    40. 		while (it != lt.end())
    41. 		{
    42. 			//*it = 10; // 不允许修改
    43. 			cout << *it << " ";
    44. 			++it;
    45. 		}
    46. 		cout << endl;
    47. 	}
    48.

    （6）erase迭代器失效

    insert不会导致迭代器失效，无论怎么插入，iterator pos都指向原位。只不过返回值是要返回新节点的迭代器。

    erase会导致迭代器失效，只要删除了pos位置的节点，那pos就是野指针了。

    1.第一阶段

    List.h

    1. #pragma once
    2. namespace bit
    3. {
    4. 	template<class T>
    5. 	struct list_node
    6. 	{
    7. 		list_node* _next;
    8. 		list_node* _prev;
    9. 		T _data;
    10.  
    11. 		list_node(const T& val = T())
    12. 			:_next(nullptr)
    13. 			, _prev(nullptr)
    14. 			, _data(val)
    15. 		{}
    16. 	};
    17.  
    18. 	template<class T>
    19. 	struct __list_iterator  //详情见（4），list为什么不能用原生指针？因为物理空间不连续
    20. 	{
    21. 		typedef list_node Node;
    22. 		typedef __list_iterator self;
    23. 		Node* _node;
    24.  
    25. 		__list_iterator(Node* node)    //这里写构造函数是为了传参，默认生成的构造函数无法传参
    26. 			:_node(node)
    27. 		{}
    28.  
    29. 		// 析构函数  -- 节点不属于迭代器，不需要迭代器释放
    30. 		// 拷贝构造和赋值重载 -- 默认生成的浅拷贝就可以
    31.  
    32. 		T& operator*()
    33. 		{
    34. 			return _node->_data;
    35. 		}
    36.  
    37. 		T* operator->()
    38. 		{ 
    39. 			//return &(operator*());
    40. 			return &_node->_data;
    41. 		}
    42.  
    43. 		self& operator++()
    44. 		{
    45. 			_node = _node->_next;
    46. 			return *this;
    47. 		}
    48.  
    49. 		self operator++(int)
    50. 		{
    51. 			self tmp(*this);
    52. 			_node = _node->_next;
    53. 			return tmp;
    54. 		}
    55.  
    56. 		self& operator--()
    57. 		{
    58. 			_node = _node->_prev;
    59. 			return *this;
    60. 		}
    61.  
    62. 		self operator--(int)
    63. 		{
    64. 			self tmp(*this);
    65. 			_node = _node->_prev;
    66. 			return tmp;
    67. 		}
    68.  
    69.  
    70. 		bool operator!=(const self& it)
    71. 		{
    72. 			return _node != it._node;
    73. 		}
    74.  
    75. 		bool operator==(const self& it)
    76. 		{
    77. 			return _node == it._node;
    78. 		}
    79.  
    80. 	};
    81.  
    82. 	template<class T>
    83. 	class list
    84. 	{
    85. 		typedef list_node Node;
    86. 	public:
    87. 		typedef __list_iterator iterator;
    88.  
    89. 		iterator begin()
    90. 		{
    91. 			return iterator(_head->_next);    //iterator()是匿名对象，详情看（1）
    92. 			//return _head->_next; //能否直接返回  _head->_next ？——可以,详情看（2）
    93. 		}
    94.  
    95. 		iterator end()
    96. 		{
    97. 			return iterator(_head);      //iterator()是匿名对象，详情看（1）
    98. 		}
    99.  
    100. 		list()
    101. 		{
    102. 			_head = new Node();
    103. 			_head->_next = _head;
    104. 			_head->_prev = _head;
    105. 		}
    106.  
    107. 		void push_back(const T& x)
    108. 		{
    109. 			Node* tail = _head->_prev;
    110. 			Node* newnode = new Node(x);
    111.  
    112. 			// _head       tail  newnode
    113. 			tail->_next = newnode;
    114. 			newnode->_prev = tail;
    115. 			newnode->_next = _head;
    116. 			_head->_prev = newnode;
    117. 		}
    118.  
    119. 	private:
    120. 		Node* _head;
    121. 	};
    122.  
    123. 	void test_list1()
    124. 	{
    125. 		list<int> lt;
    126. 		lt.push_back(1);
    127. 		lt.push_back(2);
    128. 		lt.push_back(3);
    129. 		lt.push_back(4);
    130.  
    131. 		list<int>::iterator it = lt.begin();
    132. 		while (it != lt.end())
    133. 		{
    134. 			cout << *it << " ";
    135. 			++it;
    136. 		}
    137. 		cout << endl;
    138. 	}
    139.  
    140. 	struct AA
    141. 	{
    142. 		AA(int a1 = 0, int a2 = 0)
    143. 			:_a1(a1)
    144. 			, _a2(a2)
    145. 		{}
    146.  
    147. 		int _a1;
    148. 		int _a2;
    149. 	};
    150.  
    151. 	void test_list2()
    152. 	{
    153. 		list lt;
    154. 		lt.push_back(AA(1, 1));
    155. 		lt.push_back(AA(2, 2));
    156. 		lt.push_back(AA(3, 3));
    157. 		lt.push_back(AA(4, 4));
    158.  
    159. 		// 迭代器模拟的是指针行为
    160. 		// int* it  *it
    161. 		// AA*  it  *it  it->
    162. 		list::iterator it = lt.begin();
    163. 		while (it != lt.end())
    164. 		{
    165. 			//cout << (*it)._a1 << "-"<< (*it)._a2 <<" ";
    166. 			cout << it->_a1 << "-" << it->_a2 << " ";    //it->_a1解释，详情见(3)
    167. 			++it;
    168. 		}
    169. 		cout << endl;
    170. 	}
    171. }

    Test.cpp

    1. int main()
    2. {
    3. 	bit::test_list2();
    4.  
    5. 	return 0;
    6. }

    2.第二阶段 const迭代器

    List.h

    1. #pragma once
    2. #include 
    3.  
    4. namespace bit
    5. {
    6. 	template<class T>
    7. 	struct list_node
    8. 	{
    9. 		list_node* _next;
    10. 		list_node* _prev;
    11. 		T _data;
    12.  
    13. 		list_node(const T& val = T())
    14. 			:_next(nullptr)
    15. 			, _prev(nullptr)
    16. 			, _data(val)
    17. 		{}
    18. 	};
    19.  
    20. 	// typedef __list_iterator iterator;
    21. 	// typedef __list_iterator const_iterator;
    22.  
    23. 	template<class T, class Ref, class Ptr>
    24. 	struct __list_iterator
    25. 	{
    26. 		typedef list_node Node;
    27. 		typedef __list_iterator self;
    28. 		Node* _node;
    29.  
    30. 		__list_iterator(Node* node)
    31. 			:_node(node)
    32. 		{}
    33.  
    34. 		// 析构函数  -- 节点不属于迭代器，不需要迭代器释放
    35. 		// 拷贝构造和赋值重载 -- 默认生成的浅拷贝就可以
    36.  
    37. 		// *it
    38. 		Ref operator*()
    39. 		{
    40. 			return _node->_data;
    41. 		}
    42.  
    43. 		Ptr operator->()
    44. 		{ 
    45. 			//return &(operator*());
    46. 			return &_node->_data;
    47. 		}
    48.  
    49. 		self& operator++()
    50. 		{
    51. 			_node = _node->_next;
    52. 			return *this;
    53. 		}
    54.  
    55. 		self operator++(int)
    56. 		{
    57. 			self tmp(*this);
    58. 			_node = _node->_next;
    59. 			return tmp;
    60. 		}
    61.  
    62. 		self& operator--()
    63. 		{
    64. 			_node = _node->_prev;
    65. 			return *this;
    66. 		}
    67.  
    68. 		self operator--(int)
    69. 		{
    70. 			self tmp(*this);
    71. 			_node = _node->_prev;
    72. 			return tmp;
    73. 		}
    74.  
    75.  
    76. 		bool operator!=(const self& it)
    77. 		{
    78. 			return _node != it._node;
    79. 		}
    80.  
    81. 		bool operator==(const self& it)
    82. 		{
    83. 			return _node == it._node;
    84. 		}
    85.  
    86. 	};
    87.  
    88. 	// 复用性很差
    89. 	// 单独实现一个类，支持不能修改迭代器指向节点的数据
    90. 	//template
    91. 	//struct __list_const_iterator;
    92.  
    93.  
    94.  
    95. 	template<class T>
    96. 	class list
    97. 	{
    98. 		typedef list_node Node;
    99. 	public:
    100. 		typedef __list_iterator iterator;
    101. 		typedef __list_iteratorconst T&, const T*> const_iterator;
    102.  
    103. 		const_iterator begin() const
    104. 		{
    105. 			// list_node*
    106. 			return const_iterator(_head->_next);
    107. 		}
    108.  
    109. 		const_iterator end() const
    110. 		{
    111. 			return const_iterator(_head);
    112. 		}
    113.  
    114. 		iterator begin()
    115. 		{
    116. 			return iterator(_head->_next);
    117. 			//return _head->_next;
    118. 		}
    119.  
    120. 		iterator end()
    121. 		{
    122. 			return iterator(_head);
    123. 		}
    124.  
    125. 		list()
    126. 		{
    127. 			_head = new Node();
    128. 			_head->_next = _head;
    129. 			_head->_prev = _head;
    130. 		}
    131.  
    132. 		// lt2(lt1)
    133. 		/*list(const list& lt)
    134. 		{
    135. 		_head = new Node();
    136. 		_head->_next = _head;
    137. 		_head->_prev = _head;
    139. 		for (auto e : lt)
    140. 		{
    141. 		push_back(e);
    142. 		}
    143. 		}*/
    144.  
    145. 		void empty_init()
    146. 		{
    147. 			_head = new Node();
    148. 			_head->_next = _head;
    149. 			_head->_prev = _head;
    150. 		}
    151.  
    152. 		template <class InputIterator>
    153. 		list(InputIterator first, InputIterator last)
    154. 		{
    155. 			empty_init();
    156.  
    157. 			while (first != last)
    158. 			{
    159. 				push_back(*first);
    160. 				++first;
    161. 			}
    162. 		}
    163. 		// 17:00 继续
    164. 		void swap(list& lt)
    165. 		{
    166. 			std::swap(_head, lt._head);
    167. 		}
    168.  
    169. 		// lt2(lt1) -- 现代写法
    170. 		list(const list& lt)
    171. 		{
    172. 			empty_init();
    173. 			list tmp(lt.begin(), lt.end());
    174. 			swap(tmp);
    175. 		}
    176.  
    177. 		// lt2 = lt1
    178. 		list& operator=(list lt)
    179. 		{
    180. 			swap(lt);
    181. 			return *this;
    182. 		}
    183.  
    184. 		~list()
    185. 		{
    186. 			clear();
    187. 			delete _head;
    188. 			_head = nullptr;
    189. 		}
    190.  
    191. 		void clear()
    192. 		{
    193. 			iterator it = begin();
    194. 			while (it != end())
    195. 			{
    196. 				it = erase(it);
    197. 			}
    198. 		}
    199.  
    200. 		void push_back(const T& x)
    201. 		{
    202. 			//Node* tail = _head->_prev;
    203. 			//Node* newnode = new Node(x);
    204.  
    205. 			 _head       tail  newnode
    206. 			//tail->_next = newnode;
    207. 			//newnode->_prev = tail;
    208. 			//newnode->_next = _head;
    209. 			//_head->_prev = newnode;
    210.  
    211. 			insert(end(), x);
    212. 		}
    213.  
    214. 		void push_front(const T& x)
    215. 		{
    216. 			insert(begin(), x);
    217. 		}
    218.  
    219. 		void pop_back()
    220. 		{
    221. 			erase(--end());
    222. 		}
    223.  
    224. 		void pop_front()
    225. 		{
    226. 			erase(begin());
    227. 		}
    228.  
    229. 		// 插入在pos位置之前
    230. 		iterator insert(iterator pos, const T& x)
    231. 		{
    232. 			Node* newNode = new Node(x);
    233. 			Node* cur = pos._node;
    234. 			Node* prev = cur->_prev;
    235.  
    236. 			// prev  newnode  cur
    237. 			prev->_next = newNode;
    238. 			newNode->_prev = prev;
    239. 			newNode->_next = cur;
    240. 			cur->_prev = newNode;
    241.  
    242. 			return iterator(newNode);
    243. 		}
    244.  
    245. 		iterator erase(iterator pos)
    246. 		{
    247. 			assert(pos != end());
    248.  
    249. 			Node* cur = pos._node;
    250. 			Node* prev = cur->_prev;
    251. 			Node* next = cur->_next;
    252.  
    253. 			// prev  next
    254. 			prev->_next = next;
    255. 			next->_prev = prev;
    256. 			delete cur;
    257.  
    258. 			return iterator(next);
    259. 		}
    260.  
    261. 	private:
    262. 		Node* _head;
    263. 	};
    264.  
    265. 	void print_list(const list<int>& lt)
    266. 	{
    267. 		list<int>::const_iterator it = lt.begin();
    268. 		while (it != lt.end())
    269. 		{
    270. 			//*it = 10; // 不允许修改
    271. 			cout << *it << " ";
    272. 			++it;
    273. 		}
    274. 		cout << endl;
    275. 	}

    3.第三阶段

    易错点：

    erase中的assert漏加，clear要用迭代器实现，list 构造函数重载漏写empty_init()函数，swap应该用库里面swap交换节点，swap函数不能用const（否则无法改变，就是无法交换了），operator=参数不能带引用

    增加内容：insert，erase，头尾插，头尾删，clear，析构，构造函数的重载1个，拷贝构造(远古现代写法，共2个)，赋值运算符重载（现代写法1个）

    链表的拷贝构造要深拷贝，如果浅拷贝就会导致两个链表的头结点_head指向同一个链表

    1. #pragma once
    2. #include 
    3.  
    4. namespace bit
    5. {
    6. 	template<class T>
    7. 	struct list_node
    8. 	{
    9. 		list_node* _next;
    10. 		list_node* _prev;
    11. 		T _data;
    12.  
    13. 		list_node(const T& val = T())
    14. 			:_next(nullptr)
    15. 			, _prev(nullptr)
    16. 			, _data(val)
    17. 		{}
    18. 	};
    19.  
    20. 	// typedef __list_iterator iterator;
    21. 	// typedef __list_iterator const_iterator;
    22.  
    23. 	template<class T, class Ref, class Ptr>
    24. 	struct __list_iterator
    25. 	{
    26. 		typedef list_node Node;
    27. 		typedef __list_iterator self;
    28. 		Node* _node;
    29.  
    30. 		__list_iterator(Node* node)
    31. 			:_node(node)
    32. 		{}
    33.  
    34. 		// 析构函数  -- 节点不属于迭代器，不需要迭代器释放
    35. 		// 拷贝构造和赋值重载 -- 默认生成的浅拷贝就可以
    36.  
    37. 		// *it
    38. 		Ref operator*()
    39. 		{
    40. 			return _node->_data;
    41. 		}
    42.  
    43. 		Ptr operator->()
    44. 		{ 
    45. 			//return &(operator*());
    46. 			return &_node->_data;
    47. 		}
    48.  
    49. 		self& operator++()
    50. 		{
    51. 			_node = _node->_next;
    52. 			return *this;
    53. 		}
    54.  
    55. 		self operator++(int)
    56. 		{
    57. 			self tmp(*this);
    58. 			_node = _node->_next;
    59. 			return tmp;
    60. 		}
    61.  
    62. 		self& operator--()
    63. 		{
    64. 			_node = _node->_prev;
    65. 			return *this;
    66. 		}
    67.  
    68. 		self operator--(int)
    69. 		{
    70. 			self tmp(*this);
    71. 			_node = _node->_prev;
    72. 			return tmp;
    73. 		}
    74.  
    75.  
    76. 		bool operator!=(const self& it)
    77. 		{
    78. 			return _node != it._node;
    79. 		}
    80.  
    81. 		bool operator==(const self& it)
    82. 		{
    83. 			return _node == it._node;
    84. 		}
    85.  
    86. 	};
    87.  
    88. 	// 复用性很差
    89. 	// 单独实现一个类，支持不能修改迭代器指向节点的数据
    90. 	//template
    91. 	//struct __list_const_iterator;
    92.  
    93.  
    94.  
    95. 	template<class T>
    96. 	class list
    97. 	{
    98. 		typedef list_node Node;
    99. 	public:
    100. 		typedef __list_iterator iterator;
    101. 		typedef __list_iteratorconst T&, const T*> const_iterator;
    102.  
    103. 		const_iterator begin() const
    104. 		{
    105. 			// list_node*
    106. 			return const_iterator(_head->_next);
    107. 		}
    108.  
    109. 		const_iterator end() const
    110. 		{
    111. 			return const_iterator(_head);
    112. 		}
    113.  
    114. 		iterator begin()
    115. 		{
    116. 			return iterator(_head->_next);
    117. 			//return _head->_next;
    118. 		}
    119.  
    120. 		iterator end()
    121. 		{
    122. 			return iterator(_head);
    123. 		}
    124.  
    125. 		list()
    126. 		{
    127. 			_head = new Node();
    128. 			_head->_next = _head;
    129. 			_head->_prev = _head;
    130. 		}
    131.  
    132. 		void empty_init()
    133. 		{
    134. 			_head = new Node();
    135. 			_head->_next = _head;
    136. 			_head->_prev = _head;
    137. 		}
    138.  
    139.         //这是构造函数，是使用lt的值来进行构造的
    140. 		template <class InputIterator>
    141. 		list(InputIterator first, InputIterator last)
    142. 		{        
    143. 			empty_init();
    144.  
    145. 			while (first != last)
    146. 			{
    147. 				push_back(*first);
    148. 				++first;
    149. 			}
    150. 		}
    151.  
    152.         // lt2(lt1)    拷贝构造远古写法
    153. 		/*list(const list& lt)
    154. 		{
    155. 		_head = new Node();
    156. 		_head->_next = _head;
    157. 		_head->_prev = _head;
    159. 		for (auto e : lt)
    160. 		{
    161. 		push_back(e);
    162. 		}
    163. 		}*/
    164.  
    165. 		// 17:00 继续
    166. 		void swap(list& lt)    //不能加const，要不然修改不了了
    167. 		{
    168. 			std::swap(_head, lt._head);
    169. 		}
    170.  
    171. 		// lt2(lt1) -- 拷贝构造现代写法
    172. //链表的拷贝构造要深拷贝，如果浅拷贝就会导致两个链表的头结点_head指向同一个链表
    173. 		list(const list& lt)
    174. 		{
    175. 			empty_init();
    176. 			list tmp(lt.begin(), lt.end());
    177. 			swap(tmp);
    178. 		}
    179.  
    180. 		// lt2 = lt1
    181. 		list& operator=(list lt)
    182. 		{
    183. 			swap(lt);
    184. 			return *this;
    185. 		}
    186.  
    187. 		~list()
    188. 		{
    189. 			clear();
    190. 			delete _head;
    191. 			_head = nullptr;
    192. 		}
    193.  
    194. 		void clear()
    195. 		{
    196. 			iterator it = begin();
    197. 			while (it != end())
    198. 			{
    199. 				it = erase(it);
    200. 			}
    201. 		}
    202.  
    203. 		void push_back(const T& x)
    204. 		{
    205. 			//Node* tail = _head->_prev;
    206. 			//Node* newnode = new Node(x);
    207.  
    208. 			 _head       tail  newnode
    209. 			//tail->_next = newnode;
    210. 			//newnode->_prev = tail;
    211. 			//newnode->_next = _head;
    212. 			//_head->_prev = newnode;
    213.  
    214. 			insert(end(), x);
    215. 		}
    216.  
    217. 		void push_front(const T& x)
    218. 		{
    219. 			insert(begin(), x);
    220. 		}
    221.  
    222. 		void pop_back()
    223. 		{
    224. 			erase(--end());
    225. 		}
    226.  
    227. 		void pop_front()
    228. 		{
    229. 			erase(begin());
    230. 		}
    231.  
    232. 		// 插入在pos位置之前
    233. 		iterator insert(iterator pos, const T& x)
    234. 		{
    235. 			Node* newNode = new Node(x);
    236. 			Node* cur = pos._node;
    237. 			Node* prev = cur->_prev;
    238.  
    239. 			// prev  newnode  cur
    240. 			prev->_next = newNode;
    241. 			newNode->_prev = prev;
    242. 			newNode->_next = cur;
    243. 			cur->_prev = newNode;
    244.  
    245. 			return iterator(newNode);
    246. 		}
    247.  
    248. 		iterator erase(iterator pos)
    249. 		{
    250. 			assert(pos != end());
    251.  
    252. 			Node* cur = pos._node;
    253. 			Node* prev = cur->_prev;
    254. 			Node* next = cur->_next;
    255.  
    256. 			// prev  next
    257. 			prev->_next = next;
    258. 			next->_prev = prev;
    259. 			delete cur;
    260.  
    261. 			return iterator(next);
    262. 		}
    263.  
    264. 	private:
    265. 		Node* _head;
    266. 	};
    267.  
    268. 	void print_list(const list<int>& lt)
    269. 	{
    270. 		list<int>::const_iterator it = lt.begin();
    271. 		while (it != lt.end())
    272. 		{
    273. 			//*it = 10; // 不允许修改
    274. 			cout << *it << " ";
    275. 			++it;
    276. 		}
    277. 		cout << endl;
    278. 	}
    279.  
    280. 	void test_list1()
    281. 	{
    282. 		list<int> lt;
    283. 		lt.push_back(1);
    284. 		lt.push_back(2);
    285. 		lt.push_back(3);
    286. 		lt.push_back(4);
    287.  
    288. 		list<int>::iterator it = lt.begin();
    289. 		while (it != lt.end())
    290. 		{
    291. 			*it = 20;
    292. 			cout << *it << " ";
    293. 			++it;
    294. 		}
    295. 		cout << endl;
    296.  
    297. 		print_list(lt);
    298. 	}
    299.  
    300. 	struct AA
    301. 	{
    302. 		AA(int a1 = 0, int a2 = 0)
    303. 			:_a1(a1)
    304. 			, _a2(a2)
    305. 		{}
    306.  
    307. 		int _a1;
    308. 		int _a2;
    309. 	};
    310.  
    311. 	void test_list2()
    312. 	{
    313. 		list lt;
    314. 		lt.push_back(AA(1, 1));
    315. 		lt.push_back(AA(2, 2));
    316. 		lt.push_back(AA(3, 3));
    317. 		lt.push_back(AA(4, 4));
    318.  
    319. 		// 迭代器模拟的是指针行为
    320. 		// int* it  *it
    321. 		// AA*  it  *it  it->
    322. 		list::iterator it = lt.begin();
    323. 		while (it != lt.end())
    324. 		{
    325. 			//cout << (*it)._a1 << "-"<< (*it)._a2 <<" ";
    326. 			cout << it->_a1 << "-" << it->_a2 << " ";
    327. 			++it;
    328. 		}
    329. 		cout << endl;
    330. 	}
    331.  
    332.  
    333. 	void test_list3()
    334. 	{
    335. 		list<int> lt;
    336. 		lt.push_back(1);
    337. 		lt.push_back(2);
    338. 		lt.push_back(3);
    339. 		lt.push_back(4);
    340.  
    341. 		lt.push_front(1);
    342. 		lt.push_front(2);
    343. 		lt.push_front(3);
    344. 		lt.push_front(4);
    345. 		for (auto e : lt)
    346. 		{
    347. 			cout << e << " ";
    348. 		}
    349. 		cout << endl;
    350.  
    351. 		lt.pop_front();
    352. 		lt.pop_front();
    353.  
    354. 		lt.pop_back();
    355. 		lt.pop_back();
    356.  
    357. 		for (auto e : lt)
    358. 		{
    359. 			cout << e << " ";
    360. 		}
    361. 		cout << endl;
    362. 	}
    363.  
    364. 	void test_list4()
    365. 	{
    366. 		list<int> lt;
    367. 		lt.push_back(1);
    368. 		lt.push_back(2);
    369. 		lt.push_back(2);
    370. 		lt.push_back(3);
    371. 		lt.push_back(4);
    372. 		lt.push_back(5);
    373. 		lt.push_back(6);
    374.  
    375. 		// 要求在偶数的前面插入这个偶数*10
    376. 		auto it1 = lt.begin();
    377. 		while (it1 != lt.end())
    378. 		{
    379. 			if (*it1 % 2 == 0)
    380. 			{
    381. 				lt.insert(it1, *it1 * 10);
    382. 			}
    383.  
    384. 			++it1;
    385. 		}
    386.  
    387. 		for (auto e : lt)
    388. 		{
    389. 			cout << e << " ";
    390. 		}
    391. 		cout << endl;
    392. 	}
    393.  
    394. 	void test_list5()
    395. 	{
    396. 		list<int> lt;
    397. 		lt.push_back(1);
    398. 		lt.push_back(2);
    399. 		lt.push_back(2);
    400. 		lt.push_back(3);
    401. 		lt.push_back(4);
    402. 		lt.push_back(5);
    403. 		lt.push_back(6);
    404.  
    405. 		// 删除所有的偶数
    406. 		/*auto it1 = lt.begin();
    407. 		while (it1 != lt.end())
    408. 		{
    409. 			if (*it1 % 2 == 0)
    410. 			{
    411. 				lt.erase(it1);
    412. 			}
    414. 			++it1;
    415. 		}*/
    416.  
    417. 		auto it1 = lt.begin();
    418. 		while (it1 != lt.end())
    419. 		{
    420. 			if (*it1 % 2 == 0)
    421. 			{
    422. 				it1 = lt.erase(it1);
    423. 			}
    424. 			else
    425. 			{
    426. 				++it1;
    427. 			}
    428. 		}
    429.  
    430. 		for (auto e : lt)
    431. 		{
    432. 			cout << e << " ";
    433. 		}
    434. 		cout << endl;
    435.  
    436. 		lt.clear();
    437.  
    438. 		for (auto e : lt)
    439. 		{
    440. 			cout << e << " ";
    441. 		}
    442. 		cout << endl;
    443.  
    444. 		lt.push_back(10);
    445. 		lt.push_back(20);
    446. 		lt.push_back(30);
    447.  
    448. 		for (auto e : lt)
    449. 		{
    450. 			cout << e << " ";
    451. 		}
    452. 		cout << endl;
    453. 	}
    454.  
    455. 	void test_list6()
    456. 	{
    457. 		list<int> lt;
    458. 		lt.push_back(1);
    459. 		lt.push_back(2);
    460. 		lt.push_back(3);
    461. 		lt.push_back(4);
    462. 		lt.push_back(5);
    463. 		lt.push_back(6);
    464.  
    465. 		list<int> lt1(lt);
    466.  
    467. 		for (auto e : lt1)
    468. 		{
    469. 			cout << e << " ";
    470. 		}
    471. 		cout << endl;
    472.  
    473. 		for (auto e : lt)
    474. 		{
    475. 			cout << e << " ";
    476. 		}
    477. 		cout << endl;
    478.  
    479. 		list<int> lt2;
    480. 		lt2.push_back(10);
    481. 		lt2.push_back(20);
    482. 		lt1 = lt2;
    483. 		for (auto e : lt2)
    484. 		{
    485. 			cout << e << " ";
    486. 		}
    487. 		cout << endl;
    488.  
    489. 		for (auto e : lt1)
    490. 		{
    491. 			cout << e << " ";
    492. 		}
    493. 		cout << endl;
    494. 	}
    495. }

    四.list 相关题目

    1. for (int i=1; i<10; ++i) myvector.push_back(i);   // 1 2 3 4 5 6 7 8 9
    2.  
    3. std::reverse(myvector.begin(),myvector.end());    // 9 8 7 6 5 4 3 2 1

    可知std::reserve 是将包括begin迭代器开始到end前一个位置进行逆置

  • 相关阅读:
    Apple Maps现在可在Firefox和Mac版Edge浏览器中使用
    天啦，从Mongo到ClickHouse我到底经历了什么？
    企业制胜采购管理分别有哪五种策略？
    C#实现顺序表定义、插入、删除、查找操作
    【已解决】pyqt5的打包exe软件图标菜单栏/任务栏/小图标/窗口图标未显示
    基于HTML+CSS+JavaScript制作简单的大学生网页设计——关于我的家乡湖南网页设计主题
    HTTP协议知识点总结-DX的笔记
    4. css资源加载 loader 解析器
    引用
    Codeforces Round #815 (Div. 2)
  • 原文地址：https://blog.csdn.net/zhang_si_hang/article/details/126011527