进阶链表——C++list

最新推荐文章于 2024-08-27 19:07:38 发布
最新推荐文章于 2024-08-27 19:07:38 发布
阅读量59 收藏
点赞数
分类专栏： C++ 文章标签： 链表 c++ list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67693066/article/details/132406192
版权

进阶链表——C++list

之前我们了解了C++的顺序表vector容器，今天我们来了解C++的链表容器list（带头双向循环链表）。

一些基础工作

在模拟实现list之前，我们先来看看文档：
在这里插入图片描述
我们重点来看看它的成员有哪些：
在这里插入图片描述我们重点实现增删查改和const和非const迭代器。
具体的文档：

https://legacy.cplusplus.com/reference/list/list/?kw=list

结点类的定义

我们的链表是由一个一个相互孤立的结点，连接起来形成的链表，在C++里我们也要像在C语言那里一样，定义结点类：
首先我们在头文件里，用命名空间跟库里的list分隔开来：

namespace My_list
{
	template<class T> //泛型编程
	//结点类定义
	struct _list_Node 
	{

	};

	class list //双向循环链表
	{

	};
}

由于结点的内容我们要经常访问我们用struct，因为struct的默认成员是公有的。

namespace My_list
{
	template<class T> //泛型编程
	//结点类定义
	struct _list_Node
	{
		T _data; //数据
		_list_Node<T>* _next; //下一个结点地址
		_list_Node<T>* _prve; //前一个结点地址

		//构造函数初始化
		_list_Node(const T& val = T())//隐式类型转换
			:_data(val)
			, _next(nullptr)
			, _prve(nullptr)
		{

		}
	};

	class list //双向循环链表
	{

	};
}

namespace My_list
{
	template<class T> //泛型编程
	//结点类定义
	struct _list_Node
	{
		T _data; //数据
		_list_Node<T>* _next; //下一个结点地址
		_list_Node<T>* _prve; //前一个结点地址

		//构造函数初始化
		_list_Node(const T& val = T())//隐式类型转换
			:_data(val)
			, _next(nullptr)
			, _prve(nullptr)
		{

		}
	};

	template<class T> //泛型编程
	class list //双向循环链表
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
	private:
		//定义私有成员
		_Node* _head;
		size_t _size;
	};
}

把list的构造函数实现一下（初始化头结点）：
写一个empty_list () 初始化头结点：

namespace My_list
{
	template<class T> //泛型编程
	//结点类定义
	struct _list_Node
	{
		T _data; //数据
		_list_Node<T>* _next; //下一个结点地址
		_list_Node<T>* _prve; //前一个结点地址

		//构造函数初始化
		_list_Node(const T& val = T())//隐式类型转换
			:_data(val)
			, _next(nullptr)
			, _prve(nullptr)
		{

		}
	};

	template<class T> //泛型编程
	class list //双向循环链表
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
	public:

		//初始化头结点
		void empty_list()
		{
			_head = new _Node;
			_head->_next = _head;
			_head->_prve = _head;

			_size = 0;
		}

		//构造函数
		list()
		{
			empty_list();
		}
	private:
		//定义私有成员
		_Node* _head;
		size_t _size;
	};
}

顺便实现一下析构函数，为了实现这个功能我们要写一个函数清理链表的所有的数据。为了实现这个功能更方便，还记得我们之前学过的迭代器吗？我们先来实现一个非const迭代器。

非const迭代器

首先list的迭代器和vector的迭代器很不一样，vector的迭代器的底层是连续的指针，所以我们直接可以对vector的迭代器直接加减，但是list是链表，list的指针是不连续的，无法直接加减（否则可能会访问到未开辟的地址。） 所以list的迭代器我们又要用自己封装一下：
我们也用struct来封装list的迭代器：

	template<class T>
	struct __list_itreator
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
		//成员
		_Node* Node;

		//构造函数
		__list_itreator(_Node* head)
			:Node(head)
		{

		}




	};

	template<class T>
	struct __list_itreator
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
		typedef __list_itreator<T> self; //typedef __list_itreator
		//成员
		_Node* Node;

		//构造函数
		__list_itreator(_Node* head)
			:Node(head)
		{

		}

		//实现后置++
		//前置++返回值也是一个迭代器，我们也可以typedef
		self& operator++()
		{
			Node = Node->_next;
			return *this;
		}

		//后置++
		self operator++(int)
		{
			self tmp(Node);
			Node = Node->_next;

			return tmp;
		}

		//前置--
		self& operator--()
		{
			Node = Node->_prve;
			return *this;
		}

		//后置--
		self operator--(int)
		{
			self tmp(Node);
			Node = Node->_prve;

			return tmp;
		}

		//解引用
		T& operator*()
		{
			return Node->_data;
		}

		//重载->
		T* operator->()
		{
			return &Node->_data;
		}

		//!=
		bool operator!=(const self& N)
		{
			return Node != N.Node;
		}

		//==
		bool operator==(const self& N)
		{
			return Node == N.Node;
		}

	};

现在我们写好了迭代器，现在我们来写我们最常写的begin( ) 和 end ( )

		typedef __list_itreator<T> iterator; //非const迭代器

		//返回第一个结点
		iterator begin()
		{
			return _head->_next;
		}

		//返回头结点
		iterator end()
		{
			return _head;
		}

clear ( )

现在我们来看看clear ( )函数的文档：
在这里插入图片描述我们来实现一下：

		//clear()
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{

			}
		}

我们while循环里面要写一个删除结点的函数：

erase ( )

在这里插入图片描述我们来实现一下：

		iterator erase(iterator pos)
		{
			_Node* cur = pos.Node;
			_Node* prve = cur->_prve;//保存cur之前的结点
			_Node* next = cur->_next;//保存cur之后的结点

			delete cur;
			prve->_next = next;
			next->_prve = prve;

			--_size;

			return iterator(next);//防止迭代器失效
		}

我们来完善clear ( )：

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

list析构函数

现在做好准备工作后，我们可以实现list的析构函数：

		//析构函数
		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

现在给大家看看我们实现的功能：

namespace My_list
{
	template<class T> //泛型编程
	//结点类定义
	struct _list_Node
	{
		T _data; //数据
		_list_Node<T>* _next; //下一个结点地址
		_list_Node<T>* _prve; //前一个结点地址

		//构造函数初始化
		_list_Node(const T& val = T())//隐式类型转换
			:_data(val)
			, _next(nullptr)
			, _prve(nullptr)
		{

		}
	};

	template<class T>
	struct __list_itreator
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
		typedef __list_itreator<T> self; //typedef __list_itreator
		//成员
		_Node* Node;

		//构造函数
		__list_itreator(_Node* head)
			:Node(head)
		{

		}

		//实现后置++
		//前置++返回值也是一个迭代器，我们也可以typedef
		self& operator++()
		{
			Node = Node->_next;
			return *this;
		}

		//后置++
		self operator++(int)
		{
			self tmp(Node);
			Node = Node->_next;

			return tmp;
		}

		//前置--
		self& operator--()
		{
			Node = Node->_prve;
			return *this;
		}

		//后置--
		self operator--(int)
		{
			self tmp(Node);
			Node = Node->_prve;

			return tmp;
		}

		//解引用
		T& operator*()
		{
			return Node->_data;
		}

		//重载->
		T* operator->()
		{
			return &Node->_data;
		}

		//!=
		bool operator!=(const self& N)
		{
			return Node != N.Node;
		}

		//==
		bool operator==(const self& N)
		{
			return Node == N.Node;
		}

	};

	template<class T> //泛型编程
	class list //双向循环链表
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
	public:
		typedef __list_itreator<T> iterator; //非const迭代器

		//返回第一个结点
		iterator begin()
		{
			return _head->_next;
		}

		//返回头结点
		iterator end()
		{
			return _head;
		}
			
		//初始化头结点
		void empty_list()
		{
			_head = new _Node;
			_head->_next = _head;
			_head->_prve = _head;

			_size = 0;
		}

		//构造函数
		list()
		{
			empty_list();
		}

		//析构函数
		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

		//clear()
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		iterator erase(iterator pos)
		{
			_Node* cur = pos.Node;
			_Node* prve = cur->_prve;//保存cur之前的结点
			_Node* next = cur->_next;//保存cur之后的结点

			delete cur;
			prve->_next = next;
			next->_prve = prve;

			--_size;

			return iterator(next);//防止迭代器失效
		}
	private:
		//定义私有成员
		_Node* _head;
		size_t _size;
	};
}

现在我们来测试一下：

	void test1()
	{
		list<int> l;
	}

在这里插入图片描述
编译器正常运行，说明运行成功了。

push_back ( )

在这里插入图片描述我们push_back ( )写起来不难但是，我们可以写好了insert直接复用：

insert ( )

我们用迭代器来完成插入动作：

		//插入
		iterator insert(iterator pos,const T& val)
		{
			_Node* cur = pos.Node;
			//保存之前的结点
			_Node* prve = cur->_prve;

			//开辟结点
			_Node* newnode = new _Node(val);

			//改变指向
			newnode->_prve = prve;
			prve->_next = newnode;

			newnode->_next = cur;
			cur->_prve = newnode;

			++_size;

			return iterator(newnode); //返回插入的位置
		}

现在我们来实现push_back()

		void push_back(const T& val)
		{
			insert(end(), val);
		}

我们来测试一下：

	void test1()
	{
		list<int> l;
		l.push_back(90);
		l.push_back(90);
		l.push_back(90);
		l.push_back(90);
		l.push_back(90);
		l.push_back(90);

		auto it = l.begin();
		while (it != l.end())
		{
			if (it != -- l.end())
			{
				cout << *it << "<=>";
				it++;
			}
			else
			{
				cout << *it ;
				it++;
			}
		}
		cout << endl;
	}

同时我们还有一个函数：push_front:

push_front ( )

在这里插入图片描述
我们也用insert复用:

		void push_front(const T& val)
		{
			insert(begin(), val);
		}

我们来测试一下：

	void test1()
	{
		list<int> l;
		l.push_back(90);
		l.push_back(190);
		l.push_back(290);
		l.push_back(390);
		l.push_back(490);
		l.push_back(590);

		l.push_front(1234);
		auto it = l.begin();
		while (it != l.end())
		{
			if (it != -- l.end())
			{
				cout << *it << "<=>";
				it++;
			}
			else
			{
				cout << *it ;
				it++;
			}
		}
		cout << endl;
	}

在这里插入图片描述

pop_back（）和 pop_front（）

在这里插入图片描述在这里插入图片描述这两个函数我们直接复用erase：

		void pop_back()
		{
			erase(--end());//最后一个节点
		}

		void pop_front()
		{
			erase(begin());
		}

测试一下：

	void test1()
	{
		list<int> l;
		l.push_back(90);
		l.push_back(190);
		l.push_back(290);
		l.push_back(390);
		l.push_back(490);
		l.push_back(590);

		l.push_front(1234);

		l.pop_back();
		l.pop_front();
		auto it = l.begin();
		while (it != l.end())
		{
			if (it != -- l.end())
			{
				cout << *it << "<=>";
				it++;
			}
			else
			{
				cout << *it ;
				it++;
			}
		}
		cout << endl;
	}

在这里插入图片描述

const迭代器

到现在我们还没有实现const迭代器，我们来实现const迭代器（注意const迭代器是指被指向的内容无法被修改，不是指针本身不能被改。）
大家可以这样理解，非const迭代器和const迭代器本质就是两个不同的迭代器，只不过一个的对象是非const对象，另一个的对象是const对象：
所以我们写const迭代器就是重新写一个对象是const的迭代器：

	//const迭代器
	template<class T>
	struct __list_const_itreator
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
		typedef __list_const_itreator<T> self; //typedef __list_itreator
		//成员
		_Node* Node;

		//构造函数
		__list_const_itreator(_Node* head)
			:Node(head)
		{

		}

		//实现后置++
		//前置++返回值也是一个迭代器，我们也可以typedef
		self& operator++()
		{
			Node = Node->_next;
			return *this;
		}

		//后置++
		self operator++(int)
		{
			self tmp(Node);
			Node = Node->_next;

			return tmp;
		}

		//前置--
		self& operator--()
		{
			Node = Node->_prve;
			return *this;
		}

		//后置--
		self operator--(int)
		{
			self tmp(Node);
			Node = Node->_prve;

			return tmp;
		}

		//解引用
		const T& operator*() 
		{
			return Node->_data;
		}

		//重载->
		const T* operator->()
		{
			return &Node->_data;
		}

		//!=
		bool operator!=(const self& N)
		{
			return Node != N.Node;
		}

		//==
		bool operator==(const self& N)
		{
			return Node == N.Node;
		}

	};

但大家发现除了“ * ” 和 “ -> ”运算符的返回值不同，其他的都一样，再重复写，代码有点冗余，这个时候我们可以又用模板：

	//定义T&返回值为Ref,定义T*返回值Ptr
	template<class T, class Ref, class Ptr>
	struct __list_itreator
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
		typedef __list_itreator<T,Ref,Ptr> self; //typedef __list_itreator
		//成员
		_Node* Node;

		//构造函数
		__list_itreator(_Node* head)
			:Node(head)
		{

		}

		//实现后置++
		//前置++返回值也是一个迭代器，我们也可以typedef
		self& operator++()
		{
			Node = Node->_next;
			return *this;
		}

		//后置++
		self operator++(int)
		{
			self tmp(Node);
			Node = Node->_next;

			return tmp;
		}

		//前置--
		self& operator--()
		{
			Node = Node->_prve;
			return *this;
		}

		//后置--
		self operator--(int)
		{
			self tmp(Node);
			Node = Node->_prve;

			return tmp;
		}

		//解引用
		Ref operator*()
		{
			return Node->_data;
		}

		//重载->
		Ptr operator->()
		{
			return &Node->_data;
		}

		//!=
		bool operator!=(const self& N)
		{
			return Node != N.Node;
		}

		//==
		bool operator==(const self& N)
		{
			return Node == N.Node;
		}

	};

这时候我们就很简单了：

		typedef __list_itreator<T, T&, T*> iterator; //非const迭代器
		typedef __list_itreator<T, const T&, const T*> 
			const_iterator; //const迭代器

拷贝构造函数list(const list& It)

有了const迭代器，我们就可以实现拷贝构造函数list(const list& It)

		//拷贝构造
		list(const list<T>& lt)
		{
			empty_list();
			for (auto e : lt)
			{
				push_back(e);
			}
		}

	void test2()
	{
		list<int> l;
		l.push_back(90);
		l.push_back(190);
		l.push_back(290);
		l.push_back(390);
		l.push_back(490);
		l.push_back(590);

		list<int> lt(l);

	}

在这里插入图片描述附上源码：

#pragma once
#include<iostream>
using namespace std;

namespace My_list
{
	template<class T> //泛型编程
	//结点类定义
	struct _list_Node
	{
		T _data; //数据
		_list_Node<T>* _next; //下一个结点地址
		_list_Node<T>* _prve; //前一个结点地址

		//构造函数初始化
		_list_Node(const T& val = T())//隐式类型转换
			:_data(val)
			, _next(nullptr)
			, _prve(nullptr)
		{

		}
	};

	//定义T&返回值为Ref,定义T*返回值Ptr
	template<class T, class Ref, class Ptr>
	struct __list_itreator
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
		typedef __list_itreator<T,Ref,Ptr> self; //typedef __list_itreator
		//成员
		_Node* Node;

		//构造函数
		__list_itreator(_Node* head)
			:Node(head)
		{

		}

		//实现后置++
		//前置++返回值也是一个迭代器，我们也可以typedef
		self& operator++()
		{
			Node = Node->_next;
			return *this;
		}

		//后置++
		self operator++(int)
		{
			self tmp(Node);
			Node = Node->_next;

			return tmp;
		}

		//前置--
		self& operator--()
		{
			Node = Node->_prve;
			return *this;
		}

		//后置--
		self operator--(int)
		{
			self tmp(Node);
			Node = Node->_prve;

			return tmp;
		}

		//解引用
		Ref operator*()
		{
			return Node->_data;
		}

		//重载->
		Ptr operator->()
		{
			return &Node->_data;
		}

		//!=
		bool operator!=(const self& N)
		{
			return Node != N.Node;
		}

		//==
		bool operator==(const self& N)
		{
			return Node == N.Node;
		}

	};

	const迭代器
	//template<class T>
	//struct __list_const_itreator
	//{
	//	typedef _list_Node<T> _Node; //typedef _list_Node<T>
	//	typedef __list_const_itreator<T> self; //typedef __list_itreator
	//	//成员
	//	_Node* Node;

	//	//构造函数
	//	__list_const_itreator(_Node* head)
	//		:Node(head)
	//	{

	//	}

	//	//实现后置++
	//	//前置++返回值也是一个迭代器，我们也可以typedef
	//	self& operator++()
	//	{
	//		Node = Node->_next;
	//		return *this;
	//	}

	//	//后置++
	//	self operator++(int)
	//	{
	//		self tmp(Node);
	//		Node = Node->_next;

	//		return tmp;
	//	}

	//	//前置--
	//	self& operator--()
	//	{
	//		Node = Node->_prve;
	//		return *this;
	//	}

	//	//后置--
	//	self operator--(int)
	//	{
	//		self tmp(Node);
	//		Node = Node->_prve;

	//		return tmp;
	//	}

	//	//解引用
	//	const T& operator*() 
	//	{
	//		return Node->_data;
	//	}

	//	//重载->
	//	const T* operator->()
	//	{
	//		return &Node->_data;
	//	}

	//	//!=
	//	bool operator!=(const self& N)
	//	{
	//		return Node != N.Node;
	//	}

	//	//==
	//	bool operator==(const self& N)
	//	{
	//		return Node == N.Node;
	//	}

	//};

	template<class T> //泛型编程
	class list //双向循环链表
	{
		typedef _list_Node<T> _Node; //typedef _list_Node<T>
	public:
		typedef __list_itreator<T, T&, T*> iterator; //非const迭代器
		typedef __list_itreator<T, const T&, const T*> 
			const_iterator; //const迭代器

		//返回第一个结点
		const_iterator begin() const
		{
			return _head->_next;
		}

		//返回头结点
		const_iterator end() const
		{
			return _head;
		}

		//返回第一个结点
		iterator begin()
		{
			return _head->_next;
		}

		//返回头结点
		iterator end()
		{
			return _head;
		}
			
		//初始化头结点
		void empty_list()
		{
			_head = new _Node;
			_head->_next = _head;
			_head->_prve = _head;

			_size = 0;
		}

		//拷贝构造
		list(const list<T>& lt)
		{
			empty_list();
			for (auto e : lt)
			{
				push_back(e);
			}
		}

		//构造函数
		list()
		{
			empty_list();
		}

		//析构函数
		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

		//clear()
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		void push_back(const T& val)
		{
			insert(end(), val);
		}

		void push_front(const T& val)
		{
			insert(begin(), val);
		}

		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(begin());
		}

		//插入
		iterator insert(iterator pos,const T& val)
		{
			_Node* cur = pos.Node;
			//保存之前的结点
			_Node* prve = cur->_prve;

			//开辟结点
			_Node* newnode = new _Node(val);

			//改变指向
			newnode->_prve = prve;
			prve->_next = newnode;

			newnode->_next = cur;
			cur->_prve = newnode;

			++_size;

			return iterator(newnode); //返回插入的位置
		}

		iterator erase(iterator pos)
		{
			_Node* cur = pos.Node;
			_Node* prve = cur->_prve;//保存cur之前的结点
			_Node* next = cur->_next;//保存cur之后的结点

			delete cur;
			prve->_next = next;
			next->_prve = prve;

			--_size;

			return iterator(next);//防止迭代器失效
		}
	private:
		//定义私有成员
		_Node* _head;
		size_t _size;
	};

	void test1()
	{
		list<int> l;
		l.push_back(90);
		l.push_back(190);
		l.push_back(290);
		l.push_back(390);
		l.push_back(490);
		l.push_back(590);

		l.push_front(1234);

		l.pop_back();
		l.pop_front();
		auto it = l.begin();
		while (it != l.end())
		{
			if (it != -- l.end())
			{
				cout << *it << "<=>";
				it++;
			}
			else
			{
				cout << *it ;
				it++;
			}
		}
		cout << endl;
	}

	void test2()
	{
		list<int> l;
		l.push_back(90);
		l.push_back(190);
		l.push_back(290);
		l.push_back(390);
		l.push_back(490);
		l.push_back(590);

		list<int> lt(l);

	}
}
落水 zh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
求回文链表——C++
净无邪博客
02-19 438
2.1题目分析 该题有三种常见解法，分别是递归、拷贝到数组再判断回文、反转后半部分链表。下面是采用后面两种方法解题。 2.2反转后半部分链表 由于回文是前后对称，故只需要反转链表后半部分内容，再与前面进行比较即可。 找到链表后半部分源码如下：
链表——非连续线性表
m0_74421524的博客
12-10 838
单链表和双链表的相同表现：1.无法在常量时间内随机访问数据。2.能够在 O(1) 时间内在给定结点之后或列表开头添加一个新结点。3.能够在 O(1) 时间内删除第一个结点。但是删除给定结点时略有不同。在单链表中，它无法获取给定结点的前一个结点，因此在删除给定结点之前我们必须花费 O(N) 时间来找出前一结点。在双链表中，这会更容易，因为我们可以使用“prev”引用字段获取前一个结点。因此我们可以在 O(1) 时间内删除给定结点。这里我们提供链表和其他数据结构（包括数组队列和栈）之间。
C++进阶——STL
2301_80158456的博客
05-01 511
STL——Standard Template Library （标准模板库）提升开发效率并保证代码质量，通过泛型编程，使得这些数据结构和算法适用于多种数据类型STL的六大组件：容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器这是用于存储数据的数据结构。STL提供了一系列通用算法。提供了访问容器中元素的方式，它是容器和算法之间的桥梁。是一种重载了函数调用操作符operator()的类或对象，使得它们可以像函数一样被调用。
C++进阶语法——STL 标准模板库（下）（Standard Template Library）【C++深度学习部署（七）】
qq_23022733的博客
11-01 744
容器类型::iterator 变量名称。而不是使用C++原生数组。
【C++进阶——STL库】
Maxinya__的博客
09-03 564
C++的STL库、容器
高频知识——C++进阶知识（高级教程）
热门推荐
wulitaotao96的博客
06-12 1万+
参考链接：https://www.runoob.com/cplusplus/cpp-interfaces.html 之前分别介绍了C++的基本语法，面向对象的设计方法，下面介绍一下C++的一些高级教程，也是面试的高频问题。 1 文件和流 iostream标准库，它提供了cin和cout方法分别用于从标准输入读取流和向标准输出写入流。 从文件读取流和向文件写入流。需要用到 C++ ...
C++进阶——STL源码之顺序容器list
qq_25065595的博客
07-31 688
list为双向环形链表： list的节点（以下源码的对应版本为 VS2015）： template<class _Value_type, class _Voidptr> struct _List_node { // list node _Voidptr _Next; // successor node, or first element if head _Voidptr _Prev; // predecessor node, or last element if hea
链表——底层原理
程序猿进阶
03-28 735
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。链表是有序的列表，但是它在内存中是存储如下： 一、单链表介绍 【1】一种最简单的结点结构如图所示，它是构成单链表的基本结点结构。在结点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的结点。因为只有一个指针结点，称为单链表： 【3】在单链表结构中还
【LeetCode每日一题】206. 反转链表 —— 递归（C/C++）
Layman的博客
04-12 172
一看就会，一写就废？反转链表，只要屁股连头，头连屁股就好啦 ^ - ^qaq； 在遍历列表时，将当前节点的 next 指针改为指向前一个元素。由于节点没有引用其上一个节点，因此必须事先存储其前一个元素。在更改引用之前，还需要另一个指针来存储下一个节点。不要忘记在最后返回新的头引用！
C语言进阶——嵌入式系统高级C语言编程，强烈推荐 (课程中范例代码)(东大 凌明 ).rar
09-09
"ASIX Win link list 第五讲代码.rar"和"C语言进阶-lmalloc 第四讲代码.rar"这两个压缩文件分别对应于课程的第四讲和第五讲，提供了实际的编程示例，帮助学习者理解和实践链表（link list）以及内存管理（lmalloc）...
【C++养成计划】链表 —— 快速上手STL list 类（Day11）
不积跬步，无以至千里！
06-06 3401
一万字 C++ list 类详细整理，手把手教你玩转链表~
【C++】链表
qq_38801607的博客
08-22 571
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 485
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1328
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
c语言用if语句制作点单程序
2301_81968528的博客
08-20 306
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
初识顺序表---C语言
weixin_74202161的博客
08-23 346
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
Dijkstra(c++)
weixin_73378557的博客
08-24 494
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
坐牢第三十天（c++）
最新发布
m0_62828714的博客
08-27 298
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++程序设计——链表输出详解
"这篇PPT源自谭浩强的C++教材，主要讲解如何输出链表。在链表的输出函数`print`中，通过指针遍历链表节点，逐个打印节点数据。示例中展示了链表节点的内存布局，包括节点变量如`num`和`score`，以及链表的结构。链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值