• C++ list容器的实现及讲解

    所需要的基础知识

    对C++类的基本了解 默认构造函数 操作符重载 this指针 引用 模板等知识具有一定的了解，阅读该文章会很轻松。

    链表节点

    1. 	template<class T>
    2. 	struct list_node
    3. 	{
    4. 		T _data;
    5. 		list_node* _next;
    6. 		list_node* _prev;
    7.  
    8. 		list_node(const T& x = T())
    9. 			:_data(x)
    10. 			, _next(nullptr)//只需要将链表的节点初始化为空 在链表对象中重新进行节点的设置
    11. 			, _prev(nullptr)
    12. 		{
    13.  
    14. 		}
    15. 	};

    template 是类模板 取决于链表存的数据类型 因为链表可以存许多类型的数据类型 那么只要显示传类型 就可以反复去复用 类模板 但是该写的代码编译器会帮你写 就是每个类型都会有一份代码  

    默认构造函数 对链表成员进行初始化 运用了初始化列表 在花括号中只能进行赋值 不是初始化

    链表list中的成员及函数 

    插入 

    从插入函数的实现就可以看出 该链表是双向循环链表

    1. 		iterator insert(iterator pos, const T& x)
    2. 		{
    3. 			node* cur = pos.node;
    4. 			node* newnode = new node(x);
    5. 			newnode->_next = cur->_next;
    6. 			newnode->_prev = cur;
    7. 			cur->_next->_prev = newnode;
    8. 			cur->_next = newnode;
    9.  
    10. 			++_size;
    11. 			return newnode;
    12. 		}

    插入和C语言中链表的插入没有区别 创建一个新节点 先对新结点进行操作 再对要插入的位置进行操作一面将插入的位置丢失 无法将双向循环链表连接上

    返回值是新节点的位置 防止你再再此处插入 方便插入

    下面的头插尾插都是对插入接口的赋用  

    1. 		void push_back(const T& x)
    2. 		{
    3. 			insert(--end(), x);
    4. 		}
    5. 		void push_front(const T& x)
    6. 		{
    7. 			insert(begin(), x);
    8. 		}

    链表的遍历靠的就是迭代器 所以传迭代器就知道了链表的节点位置 依次可以插入 如果你要任意位置插入 那就要计算 迭代器的位置 进行传入  

    删除

    1. 		iterator earse(iterator pos)
    2. 		{
    3. 			node* cur = pos.node;
    4. 			node* next = cur->_next;
    5. 			node* prev = cur->_prev;
    6. 			delete cur;
    7. 			next->_prev = prev;
    8. 			prev->_next = next;
    9. 			
    10. 			--_size;
    11. 			return iterator(next);
    12. 		}

    删除也是和之前讲过的C语言部分链表一样 删除操作要返回下一个位置的迭代器 

    返回值这样设计 就可以自动向后遍历删除

    头删尾删 就是对删除链表的复用

    1. 		void pop_back()
    2. 		{
    3. 			earse(--end());
    4. 		}
    5. 		void pop_front()
    6. 		{
    7. 			earse(begin());
    8. 		}

    链表中的迭代器调用接口

    1. 		iterator begin()
    2. 		{
    3. 			return _head->_next;
    4. 		}
    5. 		iterator end()
    6. 		{
    7. 			return _head;
    8. 		}
    9. 		const_iterator begin()const
    10. 		{
    11. 			return const_iterator(_head->_next);
    12. 		}
    13. 		const_iterator end()const
    14. 		{
    15. 			return const_iterator(_head);
    16. 		}
    17.  
    18. 		reverse_iterator rbegin()
    19. 		{
    20. 			return reverse_iterator(end());
    21. 		}
    22. 		reverse_iterator rend()
    23. 		{
    24. 			return reverse_iterator(begin());
    25. 		}
    26.  
    27. 		const_reverse_iterator rbegin()const
    28. 		{
    29. 			return const_reverse_iterator(end());
    30. 		}  
    31. 		const_reverse_iterator rend()const
    32. 		{
    33. 			return const_reverse_iterator(begin());
    34. 		}

     迭代器再外面就是这样调用的 只需调用list函数中的正向和反向迭代器接口 就可以进行正反向遍历

    清除函数clear()

    1. 		void clear()
    2. 		{
    3. 			iterator it = begin();
    4. 			while (it != end())
    5. 			{
    6. 				it = earse(it);
    7. 				//it++;//因为earse()返回的是该节点下一个节点 所以不用在进行++
    8. 			}
    9. 		}

     clear()就是复用earse()函数 只保留头节点_head

    析构函数

    1. 		~list()
    2. 		{
    3. 			clear();
    4. 			_size = 0;
    5. 			delete _head;
    6. 			_head = nullptr;
    7. 		}

     编译器自己写的析构函数对自定义类型不进行析构 链表节点就是自定义类型 所以需要自己写析构函数 进行数据的释放 

    赋值操作符重载“=”

    1. 		void swap(list& lt)
    2. 		{
    3. 			std::swap(_head, lt._head);
    4. 			std::swap(_size, lt._size);
    5. 		}
    6. 		list& operator=(list x)
    7. 		{
    8. 			swap(x);
    9. 			return *this;
    10. 		}

     operator=(参数) 参数是进行传值传参 传值传参就是原数据的拷贝 出了该函数这个拷贝参数x会自行销毁 会调用自己的构造函数 既然x和原数据类型值是一样的 所以就可以进行交换

    swap(x)->this->swap(x) 在list函数内部除了static修饰的函数没有this指针其他函数都有this指针 你可以在函数内部进行显示调用 但是函数参数不能出现

    如：A=B A的地址就是this B就是x; 

    链表中的类型及函数讲解

         

    • 正向迭代器

        typedef的类型简化

    1.         typedef list_node Node;
    2. 		typedef list_iterator self;

            由于原始类型过于繁杂 所以进行类型简化 

    迭代器函数介绍：

            默认构造函数

    1.         list_iterator(Node* x)
    2. 			:node(x)
    3. 		{
    4.  
    5. 		}

            因为迭代器中存的是 链表的节点 是自定义类型 需要调用对应的默认初始化函数 

            正向迭代器的功能就是将链表正向遍历一遍 

            既然是遍历肯定要将链表中的数据打印出来那就需要对应的函数去获取

            操作符重载：

            “*”->operator*()

    1. 		Ref operator*()
    2. 		{
    3. 			return node->_data;
    4. 		}

            "->"operator->()

    1.         Ptr operator->()
    2. 		{
    3. 			return &node->_data;
    4. 		}

         

    迭代器中存的是链表的节点 然而用迭代器是这么用的

            list::iterator it = begin()获取迭代器的首 it就是指针 所以你想获取链表节点中的数据就需要重载“*和->" *it的功能就是获取该节点的数据 只是迭代器中对其进行了重载实现 所以你可以这样使用 ”->"道理也是一样 都是迭代器进行了重载实现 功能就是通过指针进行迭代器中共有函数和成员的直接获取 淡然*it也是可以就需要叫“.”操作符进行公有成员和函数的获取

            这两个返回值的类型是不一样的 “*”既然是数据 那么就可以引用返回 只要你不销毁程序不结束没有出作用域 就可以进行传引用返回 “->"返回的就是指针类型就是T* 他的返回值前面有个&取地址符 然而”*“和”->"两者遇到一起就抵消了 就剩下node->_data也就是你想要的节点数据 我就是这样理解操作符“->"的重载实现原理的

              "前置++，--，后置++，--"

    1. 		self& operator++()
    2. 		{
    3. 			node = node->_next;
    4. 			return *this;
    5. 		}
    6. 		self& operator--()
    7. 		{
    8. 			node = node->_prev;
    9. 			return *this;
    10. 		}
    11. 		self operator++(int)
    12. 		{
    13. 			self tmp(*this);
    14. 			node = node->_next;
    15. 			return tmp;
    16. 		}
    17. 		self operator--(int)
    18. 		{
    19. 			self tmp(*this);
    20. 			node = node->_prev;
    21. 			return tmp;
    22. 		}

            前置与后置操作的区别就是前置不需要数据类型进行占位 构成操作符重载

            那么返回值类型就是迭代器的类型 返回值根据前置和后置的功能有所不同

            前置：先++/--在用 也就迭代器要返回下一个位置 由于下一个位置是存在的你不销毁或者程序不结束 那么该位置始终是有效的 所以可以返回引用 &

            后置：先用再++/-- 也就是要返回当前的值还要进行++/-- 那就要储存当前的值 不然进行完++/--找起来有点麻烦 可以找因为list的结构是双向循环链表可以向前查找 返回++/--的前一个节点就行

    拷贝当前数据出了作用域该数据会销毁 那么就不能进行引用& 返回 只能传值拷贝返回

            “比较操作符!=,==”因为不需要大于或小于 比较对象是指针

    1. 		bool operator==(const self& x)
    2. 		{
    3. 			return node == x.node;
    4. 		}
    5. 		bool operator!=(const self& x)
    6. 		{
    7. 			return node != x.node;
    8. 		}

    既然是地址的比较就应该返回 bool类型的值 （true/false） 

    反向迭代器

    由上图可以看出 反向迭代器是对正向迭代器的赋用 而且反向迭代器中成员存的是正向迭代器_it

    反向迭代器的默认构造函数

    1. 		reverse_iterator(iterator it)
    2. 			:_it(it)
    3. 		{
    4.  
    5. 		}

     用正向迭代器对其进行初始化

    操作符重载——>"*和->"

    1. 		Ref operator*()
    2. 		{
    3. 			iterator tmp = _it;
    4. 			return *(--tmp);
    5. 		}
    6. 		Ptr operator->()
    7. 		{
    8. 			iterator tmp = _it;
    9. 			return &(operator*());
    10. 		}

    观察上图的反向迭代器的首部 再要获取节点的前一个位置 所以要先保存当前节点 再对当前进行前移 依次达到目的 

    “->"返回的就是指针类型就是T* 他的返回值前面有个&取地址符 然而”*“和”->"两者遇到一起就抵消了 就剩下node->_data也就是你想要的节点数据 我就是这样理解操作符“->"的重载实现原理的

    所以返回的既然是数据 那么就可以复用 之前实现的“operator*()”, 

    Ref -> T& Ptr -> T* T就是模板参数 取决于外面链表中存的是什么类型的参数

    操作符->前置“++/--”和后置"++/--"

    1. 		self& operator++()
    2. 		{
    3. 			--_it;
    4. 			return *this;
    5. 		}
    6. 		self& operator--()
    7. 		{
    8. 			++_it;
    9. 			return *this;
    10. 		}
    11. 		self operator++(int)
    12. 		{
    13. 			self tmp(*this);
    14. 			--_it;
    15. 			return *this;
    16. 		}
    17. 		self operator--(int)
    18. 		{
    19. 			self tmp(*this);
    20.  
    21. 			++_it;
    22. 			return *this;
    23. 		}

     前置++/-- 和后置++/-- 都是对链表节点进行操作 然而迭代器中存的是链表节点 在外界对迭代器进行操作 为了使类型可以对上 所以返回self 就是反向迭代器的简化类型

    反向迭代器的运用

    前置++/-- 和后置++/--原理是一样的 先++再用 先用再++ 在正向迭代器中讲过 所以不再重复

    迭代器判断是否相等

    1. 		bool operator!=(const self& s)
    2. 		{
    3. 			return _it != s._it;
    4. 		}

     

    链表list对象的实现

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8.  
    9. namespace DZ
    10. {
    11. 	template<class T>
    12. 	struct list_node
    13. 	{
    14. 		T _data;
    15. 		list_node* _next;
    16. 		list_node* _prev;
    17.  
    18. 		list_node(const T& x = T())
    19. 			:_data(x)
    20. 			, _next(nullptr)//只需要将链表的节点初始化为空 在链表对象中重新进行节点的设置
    21. 			, _prev(nullptr)
    22. 		{
    23.  
    24. 		}
    25. 	};
    26. 	template<class T, class Ref, class Ptr>
    27. 	class list_iterator
    28. 	{
    29. 	public:
    30. 		typedef list_node Node;
    31. 		typedef list_iterator self;
    32.  
    33. 		list_iterator(Node* x)
    34. 			:node(x)
    35. 		{
    36.  
    37. 		}
    38.  
    39. 		self& operator++()
    40. 		{
    41. 			node = node->_next;
    42. 			return *this;
    43. 		}
    44. 		self& operator--()
    45. 		{
    46. 			node = node->_prev;
    47. 			return *this;
    48. 		}
    49. 		self operator++(int)
    50. 		{
    51. 			self tmp(*this);
    52. 			node = node->_next;
    53. 			return tmp;
    54. 		}
    55. 		self operator--(int)
    56. 		{
    57. 			self tmp(*this);
    58. 			node = node->_prev;
    59. 			return tmp;
    60. 		}
    61. 		bool operator==(const self& x)
    62. 		{
    63. 			return node == x.node;
    64. 		}
    65. 		bool operator!=(const self& x)
    66. 		{
    67. 			return node != x.node;
    68. 		}
    69. 		Ref operator*()
    70. 		{
    71. 			return node->_data;
    72. 		}
    73. 		Ptr operator->()
    74. 		{
    75. 			return &node->_data;
    76. 		}
    77. 		
    78.  
    79. 		Node* node;
    80.  
    81. 	};
    82. 	template<class iterator,class Ref,class Ptr>
    83. 	class reverse_iterator
    84. 	{
    85. 	public:
    86. 		iterator _it;
    87. 		typedef reverse_iterator self;
    88. 		reverse_iterator(iterator it)
    89. 			:_it(it)
    90. 		{
    91.  
    92. 		}
    93. 		Ref operator*()
    94. 		{
    95. 			iterator tmp = _it;
    96. 			return *(--tmp);
    97. 		}
    98. 		Ptr operator->()
    99. 		{
    100. 			iterator tmp = _it;
    101. 			return &(operator*());
    102. 		}
    103. 		self& operator++()
    104. 		{
    105. 			--_it;
    106. 			return *this;
    107. 		}
    108. 		self& operator--()
    109. 		{
    110. 			++_it;
    111. 			return *this;
    112. 		}
    113. 		self operator++(int)
    114. 		{
    115. 			self tmp(*this);
    116. 			--_it;
    117. 			return *this;
    118. 		}
    119. 		self operator--(int)
    120. 		{
    121. 			self tmp(*this);
    122.  
    123. 			++_it;
    124. 			return *this;
    125. 		}
    126. 		bool operator!=(const self& s)
    127. 		{
    128. 			return _it != s._it;
    129. 		}
    130. 	};
    131. 	template<class T>
    132. 	class list
    133. 	{
    134. 	public:
    135. 		typedef list_node node;
    136. 		typedef list_iterator iterator;
    137. 		typedef list_iteratorconst T&, const T*> const_iterator;
    138. 		typedef reverse_iteratorconst T&, const T*> const_reverse_iterator;
    139. 		typedef reverse_iterator reverse_iterator;
    140.  
    141. 		iterator begin()
    142. 		{
    143. 			return _head->_next;
    144. 		}
    145. 		iterator end()
    146. 		{
    147. 			return _head;
    148. 		}
    149. 		const_iterator begin()const
    150. 		{
    151. 			return const_iterator(_head->_next);
    152. 		}
    153. 		const_iterator end()const
    154. 		{
    155. 			return const_iterator(_head);
    156. 		}
    157.  
    158. 		reverse_iterator rbegin()
    159. 		{
    160. 			return reverse_iterator(end());
    161. 		}
    162. 		reverse_iterator rend()
    163. 		{
    164. 			return reverse_iterator(begin());
    165. 		}
    166.  
    167. 		const_reverse_iterator rbegin()const
    168. 		{
    169. 			return const_reverse_iterator(end());
    170. 		}
    171. 		const_reverse_iterator rend()const
    172. 		{
    173. 			return const_reverse_iterator(begin());
    174. 		}
    175.  
    176. 		void empty_inti()
    177. 		{
    178. 			_head = new node;
    179. 			_head->_next = _head;
    180. 			_head->_prev = _head;
    181. 		}
    182. 		//it1(it2)
    183. 		list(const list& x)
    184. 		{
    185. 			empty_inti();
    186. 			for (auto& e : x)
    187. 			{
    188. 				push_back(e);
    189. 			}
    190. 		}
    191.  
    192.  
    193.  
    194. 		list()
    195. 		{
    196. 			empty_inti();
    197.  
    198. 			_size = 0;
    199. 		}
    200.  
    201. 		void push_back(const T& x)
    202. 		{
    203. 			insert(--end(), x);
    204. 		}
    205. 		void push_front(const T& x)
    206. 		{
    207. 			insert(begin(), x);
    208. 		}
    209. 		void pop_back()
    210. 		{
    211. 			earse(--end());
    212. 		}
    213. 		void pop_front()
    214. 		{
    215. 			earse(begin());
    216. 		}
    217. 		//list& operator=(const list& x)
    218. 		//{
    219. 		//	if (this != &x)
    220. 		//	{
    221. 		//		clear();
    222. 		//		for (auto& e : x)
    223. 		//		{
    224. 		//			push_back(e);
    225. 		//		}
    226. 		//	}
    227. 		//	return *this;
    228. 		//}
    229. 		//void swap(list& x)
    230. 		//{
    231. 		//	std::swap(_size, x._size);
    232. 		//	std::swap(_head, x._head);
    233. 		//}
    234. 		void swap(list& lt)
    235. 		{
    236. 			std::swap(_head, lt._head);
    237. 			std::swap(_size, lt._size);
    238. 		}
    239. 		list& operator=(list x)
    240. 		{
    241. 			swap(x);
    242. 			return *this;
    243. 		}
    244. 		~list()
    245. 		{
    246. 			clear();
    247. 			_size = 0;
    248. 			delete _head;
    249. 			_head = nullptr;
    250. 		}
    251. 		void clear()
    252. 		{
    253. 			iterator it = begin();
    254. 			while (it != end())
    255. 			{
    256. 				it = earse(it);
    257. 				//it++;//因为earse()返回的是该节点下一个节点 所以不用在进行++
    258. 			}
    259. 		}
    260.  
    261. 		iterator insert(iterator pos, const T& x)
    262. 		{
    263. 			node* cur = pos.node;
    264. 			node* newnode = new node(x);
    265. 			newnode->_next = cur->_next;
    266. 			newnode->_prev = cur;
    267. 			cur->_next->_prev = newnode;
    268. 			cur->_next = newnode;
    269.  
    270. 			++_size;
    271. 			return newnode;
    272. 		}
    273. 		iterator earse(iterator pos)
    274. 		{
    275. 			node* cur = pos.node;
    276. 			node* next = cur->_next;
    277. 			node* prev = cur->_prev;
    278. 			delete cur;
    279. 			next->_prev = prev;
    280. 			prev->_next = next;
    281. 			
    282. 			--_size;
    283. 			return iterator(next);
    284. 		}
    285.  
    286. 		size_t size()
    287. 		{
    288. 			return _size;
    289. 		}
    290. 	private:
    291. 		size_t _size;
    292. 		node* _head;
    293. 	};
    294.  
    295. 	void test_list1()
    296. 	{
    297. 		list<int> lt;
    298. 		lt.push_back(1);
    299. 		lt.push_back(2);
    300. 		lt.push_back(3);
    301. 		lt.push_back(4);
    302. 		lt.push_back(5);
    303.  
    304. 		// 封装屏蔽底层差异和实现细节
    305. 		// 提供统一的访问修改遍历方式
    306. 		list<int>::iterator it = lt.begin();
    307. 		while (it != lt.end())
    308. 		{
    309. 			*it += 20;
    310.  
    311. 			cout << *it << " ";
    312. 			++it;
    313. 		}
    314. 		cout << endl;
    315.  
    316. 		for (auto e : lt)
    317. 		{
    318. 			cout << e << " ";
    319. 		}
    320. 		cout << endl;
    321.  
    322. 		/*set s;
    323. 		s.insert(1);
    324. 		s.insert(3);
    325. 		s.insert(2);
    326. 		s.insert(4);
    328. 		set::iterator sit = s.begin();
    329. 		while (sit != s.end())
    330. 		{
    331. 			cout << *sit << " ";
    332. 			++sit;
    333. 		}
    334. 		cout << endl;*/
    335. 	}
    336.  
    337. 	void test_list2()
    338. 	{
    339. 		list<int> lt;
    340. 		lt.push_back(1);
    341. 		lt.push_back(2);
    342. 		lt.push_back(3);
    343. 		lt.push_back(4);
    344. 		lt.push_back(5);
    345.  
    346. 		list<int> lt1(lt);
    347.  
    348. 		for (auto e : lt)
    349. 		{
    350. 			cout << e << " ";
    351. 		}
    352. 		cout << endl;
    353.  
    354. 		for (auto e : lt1)
    355. 		{
    356. 			cout << e << " ";
    357. 		}
    358. 		cout << endl;
    359.  
    360. 		list<int> lt2;
    361. 		lt2.push_back(10);
    362. 		lt2.push_back(200);
    363. 		lt2.push_back(30);
    364. 		lt2.push_back(40);
    365. 		lt2.push_back(50);
    366.  
    367. 		lt1 = lt2;
    368. 		for (auto e : lt1)
    369. 		{
    370. 			cout << e << " ";
    371. 		}
    372. 		cout << endl;
    373.  
    374. 		for (auto e : lt2)
    375. 		{
    376. 			cout << e << " ";
    377. 		}
    378. 		cout << endl;
    379. 	}
    380.  
    381. 	struct AA
    382. 	{
    383. 		AA(int a1 = 0, int a2 = 0)
    384. 			:_a1(a1)
    385. 			, _a2(a2)
    386. 		{}
    387.  
    388. 		int _a1;
    389. 		int _a2;
    390. 	};
    391.  
    392. 	void test_list3()
    393. 	{
    394. 		list lt;
    395. 		lt.push_back(AA(1, 1));
    396. 		lt.push_back(AA(2, 2));
    397. 		lt.push_back(AA(3, 3));
    398.  
    399. 		list::iterator it = lt.begin();
    400. 		while (it != lt.end())
    401. 		{
    402. 			//cout << (*it)._a1<<" "<<(*it)._a2 << endl;
    403. 			cout << it->_a1 << " " << it->_a2 << endl;
    404. 			cout << it.operator->()->_a1 << " " << it.operator->()->_a1 << endl;
    405.  
    406.  
    407. 			++it;
    408. 		}
    409. 		cout << endl;
    410.  
    411. 		int* p = new int;
    412. 		*p = 1;
    413.  
    414. 		AA* ptr = new AA;
    415. 		ptr->_a1 = 1;
    416.  
    417. 	}
    418. 	template<typename Container>
    419. 	void print_container(const Container& con)
    420. 	{
    421. 		typename Container::const_iterator it = con.begin();
    422. 		while (it != con.end())
    423. 		{
    424. 			cout << *it << " ";
    425. 			++it;
    426. 		}
    427. 		cout << endl;
    428. 	}
    429.  
    430. 	void test_list4()
    431. 	{
    432. 		list<int> lt;
    433. 		lt.push_back(1);
    434. 		lt.push_back(2);
    435. 		lt.push_back(3);
    436. 		lt.push_back(4);
    437. 		lt.push_back(5);
    438. 		//print_list(lt);
    439. 		print_container(lt);
    440.  
    441. 		list lt1;
    442. 		lt1.push_back("1111111111111");
    443. 		lt1.push_back("1111111111111");
    444. 		lt1.push_back("1111111111111");
    445. 		lt1.push_back("1111111111111");
    446. 		lt1.push_back("1111111111111");
    447. 		//print_list(lt1);
    448. 		print_container(lt1);
    449.  
    450. 		vector v;
    451. 		v.push_back("222222222222222222222");
    452. 		v.push_back("222222222222222222222");
    453. 		v.push_back("222222222222222222222");
    454. 		v.push_back("222222222222222222222");
    455. 		//print_list(v);
    456. 		print_container(v);
    457. 	}
    458.  
    459. 	void test_list5()
    460. 	{
    461. 		list<int> lt;
    462. 		lt.push_back(1);
    463. 		lt.push_back(2);
    464. 		lt.push_back(3);
    465. 		lt.push_back(4);
    466. 		lt.push_back(5);
    467.  
    468.  
    469.  
    470. 		list<int>::reverse_iterator it = lt.rbegin();
    471. 		while (it != lt.rend())
    472. 		{
    473. 			cout << *it << " ";
    474. 			++it;
    475. 		}
    476. 	}
    477. }

  • 相关阅读:
    汽车行业数字化转型：时代巨变下的新机遇
    element ui中的el-tree自定义每个节点，前面加不同颜色的块
    五、java版 SpringCloud分布式微服务云架构之Java 基本数据类型
    Android热修复（代码修复+资源修复+SO动态链接库修复）
    js面试题（更新中...）
    mysqli_connect(): php_network_getaddresses: getaddrinfo failed:
    腾讯云服务器镜像TencentOS Server操作系统详细介绍
    深度学习手写简单的lstm
    使用JAVA开发情侣飞行棋小程序系统的优势与注意事项
    实用小算法
  • 原文地址：https://blog.csdn.net/2201_75324712/article/details/133207285