C++数据结构 之 链表_Linked List

最新推荐文章于 2024-07-26 11:03:14 发布
最新推荐文章于 2024-07-26 11:03:14 发布
阅读量1w 收藏 25
点赞数 5
分类专栏： C++、算法与数据结构 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu798675179/article/details/52170124
版权

C++数据结构 之 链表_Linked List

源代码只包含头文件

注：需要C++11的支持

一、链表

链表的思想类似于一根链子，环环相扣，每一个链环都是一个节点，每个节点中有自己的数据，还有指向前一个节点和后一个节点的指针。因此访问链表，不能随机访问，必须一个接一个，显然访问时间较长，但也是线性时间以内。
链表有头有尾，在本实现中，即使是空链表，头尾节点也是存在的。

支持的操作：
1、push_back (尾压入）：将节点从尾部压入链表中。
2、push_front （首压入）：将节点从首部压入链表中。
3、back 返回尾节点前一个节点的数据。
4、front 返回首节点下一个节点的数据。
5、front_insert 在当前节点的前一个位置一个新的节点。
6、back_front 在当先节点的下一个位置插入一个新的节点。
7、erase 删除当前节点，或者删除制定范围内的节点（此范围 [begin，end)，注意括号的区别）。
8、clear 删除所有，初头尾节点以外的节点。
9、resize 添加n个默认初始化数据的节点
10、sort 按照数据less函数对象给链表排序。
11、search 返回所要查找数据的迭代器。
12、begin 返回首节点的下一个节点的迭代器。
13、end 返回尾节点的迭代器。
14 、rbegin 返回为节点的上一个节点的迭代器。
15、rend 返回首节点的迭代器。

示意图：
链表

二、源代码：

#ifndef LIST_H
#define LIST_H

#include <memory>
#include <stdexcept>
#include <vector>
#include <algorithm>

using std::shared_ptr;
using std::make_shared;

template<typename Data>
class List {
	friend class const_iterator;
private:
	struct Node {
		Node() = default;

		Data data;
		shared_ptr<Node> prev = nullptr;
		shared_ptr<Node> next = nullptr;
	};

	shared_ptr<Node> head = make_shared<Node>();
	shared_ptr<Node> tail = make_shared<Node>();
	void initialize() {
		head->next = tail;
		tail->prev = head;
	}

	size_t List_Size = 0;

public:
	// CLASS const_iterator
	class const_iterator {
		friend class List<Data>;
	public:
		const_iterator() = default;
		~const_iterator() = default;
		const_iterator(shared_ptr<Node> p) : ptr(p) {}

		const Data& operator*() const {
			return ptr->data;
		}
		const_iterator& operator+(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->next != nullptr) {
					ptr = ptr->next;
				}
			}
			return *this;
		}
		const_iterator& operator-(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->prev != nullptr) {
					ptr = ptr->prev;
				}
			}
			return *this;
		}
		const_iterator& operator++() {
			ptr = ptr->next;
			return *this;
		}
		const_iterator& operator++(int) {
			const_iterator temp = *this;
			++*this;
			return temp;
		}
		const_iterator& operator--() {
			ptr = ptr->prev;
			return *this;
		}
		const_iterator& operator--(int) {
			const_iterator temp = *this;
			--*this;
			return temp;
		}
		bool operator==(const const_iterator &rhs) const {
			return ptr == rhs.ptr;
		}
		bool operator!=(const const_iterator &rhs) const {
			return !(*this == rhs);
		}

	protected:
		shared_ptr<Node> ptr;
	};

	// CLASS iterator
	class iterator : public const_iterator {
		friend class List<Data>;
	public:
		iterator() = default;
		~iterator() = default;

		Data& operator*() {
			return ptr->data;
		}
		const Data& operator*() const {
			return const_iterator::operator*();
		}
		iterator& operator+(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->next != nullptr) {
					ptr = ptr->next;
				}
			}
			return *this;
		}
		iterator& operator-(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->prev != nullptr) {
					ptr = ptr->prev;
				}
			}
			return *this;
		}
		iterator& operator++() {
			ptr = ptr->next;
			return *this;
		}
		iterator& operator++(int) {
			iterator temp = *this;
			++*this;
			return temp;
		}
		iterator& operator--() {
			ptr = ptr->prev;
			return *this;
		}
		iterator& operator--(int) {
			iterator temp = *this;
			--*this;
			return temp;
		}

	protected:
		iterator(shared_ptr<Node> p) : const_iterator(p) {}
	};

	// CLASS const_reverse_iterator
	class const_reverse_iterator {
		friend class List<Data>;
	public:
		const_reverse_iterator() = default;
		~const_reverse_iterator() = default;
		const_reverse_iterator(shared_ptr<Node> p) : ptr(p) {}

		const Data& operator*() const {
			return ptr->data;
		}
		const_reverse_iterator& operator+(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->prev != nullptr) {
					ptr = ptr->prev;
				}
			}
			return *this;
		}
		const_reverse_iterator& operator-(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->next != nullptr) {
					ptr = ptr->next;
				}
			}
			return *this;
		}
		const_reverse_iterator& operator++() {
			ptr = ptr->prev;
			return *this;
		}
		const_reverse_iterator& operator++(int) {
			const_reverse_iterator temp = *this;
			++*this;
			return temp;
		}
		const_reverse_iterator& operator--() {
			ptr = ptr->next;
			return *this;
		}
		const_reverse_iterator& operator--(int) {
			const_reverse_iterator temp = *this;
			--*this;
			return temp;
		}
		bool operator==(const const_reverse_iterator& rhs) {
			return ptr == rhs.ptr;
		}
		bool operator!=(const const_reverse_iterator& rhs) {
			return !(*this == rhs);
		}

	protected:
		shared_ptr<Node> ptr;
	};

	// CLASS reverse_iterator
	class reverse_iterator : public const_reverse_iterator {
		friend class List<Data>;
	public:
		reverse_iterator() = default;
		~reverse_iterator() = default;

		Data& operator*() {
			return ptr->data;
		}
		const Data& operator*() const {
			return const_reverse_iterator::operator*();
		}
		reverse_iterator& operator+(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->prev != nullptr) {
					ptr = ptr->prev;
				}
			}
			return *this;
		}
		reverse_iterator& operator-(long long LL) {
			for (auto i = 0; i != LL; ++i) {
				if (ptr->next != nullptr) {
					ptr = ptr->next;
				}
			}
			return *this;
		}
		reverse_iterator& operator++() {
			ptr = ptr->prev;
			return *this;
		}
		reverse_iterator& operator++(int) {
			reverse_iterator temp = *this;
			++*this;
			return temp;
		}
		reverse_iterator& operator--() {
			ptr = ptr->next;
			return *this;
		}
		reverse_iterator& operator--(int) {
			reverse_iterator temp = *this;
			--*this;
			return temp;
		}

	protected:
		reverse_iterator(shared_ptr<Node> p) : const_reverse_iterator(p) {}
	};

public:
	List() { initialize(); }
	~List() = default;

	//List(const List &rhs) {
	//	clear();
	//	for (auto &i : rhs) {
	//		push_back(i);
	//	}
	//}
	//List& operator=(const List &rhs) {
	//	if (this == &rhs) {
	//		return *this;
	//	}
	//	clear();
	//	for (auto &i : rhs) {
	//		push_back(i);
	//	}
	//	return *this;
	//}

	iterator begin() {
		return iterator(head->next);
	}
	const_iterator begin() const {
		return const_iterator(head->next);
	}
	reverse_iterator rbegin() {
		return reverse_iterator(tail->prev);
	}
	const_reverse_iterator rbegin() const {
		return const_reverse_iterator(tail->prev);
	}
	iterator end() {
		return iterator(tail);
	}
	const_iterator end() const {
		return const_iterator(tail);
	}
	reverse_iterator rend() {
		return reverse_iterator(head);
	}
	const_reverse_iterator rend() const {
		return const_reverse_iterator(head);
	}

	// Front insert.
	iterator front_insert(iterator itr, const Data& data) {
		shared_ptr<Node> p = itr.ptr;
		++List_Size;
		auto a = make_shared<Node>();
		a->data = data;
		a->prev = p->prev;
		a->next = p;
		p->prev = a;
		a->prev->next = a;
		return iterator(a);
		//return iterator(p->prev = p->prev->next = make_shared<Node>(data, p->prev, p));
	}
	iterator front_insert(iterator itr) {
		shared_ptr<Node> p = itr.ptr;
		++List_Size;
		auto a = make_shared<Node>();
		a->prev = p->prev;
		a->next = p;
		p->prev = a;
		a->prev->next = a;
		return iterator(a);
	}

	// Back_insert.
	iterator back_insert(iterator itr, const Data& data) {
		shared_ptr<Node> p = itr.ptr;
		++List_Size;
		auto a = make_shared<Node>();
		a->data = data;
		a->prev = p;
		a->next = p->next;
		p->next = a;
		a->next->prev = a;
		return iterator(a);
		//return iterator(p->next = p->next->prev = make_shared<Node>(data, p, p->next));
	}
	iterator back_insert(iterator itr) {
		shared_ptr<Node> p = itr.ptr;
		++List_Size;
		auto a = make_shared<Node>();
		a->prev = p;
		a->next = p->next;
		p->next = a;
		a->next->prev = a;
		return iterator(a);
	}

	iterator erase(iterator itr) {
		shared_ptr<Node> p = itr.ptr;
		iterator itaval(p->next);
		try {
			if (p == head) {
				throw runtime_error("No elements can erase!");
			}
			else if (p == tail) {
				throw runtime_error("No elements can erase!");
			}
			else {
				p->prev->next = p->next;
				p->next->prev = p->prev;
				--List_Size;
			}
		}
		catch (runtime_error err) {
			cout << err.what() << endl;
		}
		return itaval;
	}

	iterator erase(iterator begin, iterator end) {  // [begin, end)
		while (begin != end) {
			begin = erase(begin);
		}
		return iterator(end);
	}

	void clear() {
		while (!empty()) {
			pop_front();
		}
	}

	void print() {
		for (auto &i : *this) {
			cout << i << endl;
		}
	}

	void resize(long long LL) {
		for (auto i = 0; i != LL; ++i) {
			push_back();
		}
	}

	void resize(long long LL, const Data &x) {
		for (auto i = 0; i != LL; ++i) {
			push_back(x);
		}
	}

	void sort() {
		std::vector<Data> temp_v;
		for (auto &i : *this) {
			temp_v.push_back(i);
		}
		std::stable_sort(temp_v.begin(), temp_v.end());
		clear();
		for (auto &i : temp_v) {
			push_back(i);
		}
	}

	iterator search(const Data &x) {
		auto temp_count = 0;
		for (auto &i : *this) {
			if (i != x) {
				++temp_count;
			}
			else {
				break;
			}
		}
		return begin() + temp_count;
	}

	bool empty() { return List_Size == 0; }
	size_t size() { return List_Size; }
	Data& front() { return *begin(); }
	const Data& front() const { return front(); }
	Data& back() { return *--end(); }
	const Data& back() const { return back(); }
	void push_front() { front_insert(begin()); }
	void push_front(const Data &x) { front_insert(begin(), x); }
	void push_back() { back_insert(--end()); }
	void push_back(const Data &x) { back_insert(--end(), x); }
	void pop_front() { erase(begin()); }
	void pop_back() { erase(--end()); }

};

#endif // !LIST_H

注释：所有对节点的访问，已经抽象成为使用迭代器访问。

_MICHAEL_LIU_
关注
专栏目录
链表类LinkedList的完全c++实现
09-27
链表类LinkedList的完全c++实现，根据数据结构与算法课堂总结。
数据结构C++链表
03-04
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。
【数据结构】链表之LinkedList（无头双链表实现 + 详解 + 原码）
最新发布
明志の博客
07-26 1006
LinkedList是无头双向非循环链表学习链表的知识一定要 结合图，多画图，才能深刻理解LinkedList官方文档LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。在集合框架中， LinkedList也实现了List接口。
linklist 链表的基本操作c++
03-13
linklist 链表的基本操作c++,实现添加数据，删除，查找，插入等功能，顺利通过
数据结构 双向链表（C++）
06-07
数据结构　双向链表的实现
C++Linklist
bangdian1728的博客
07-10 617
#if 1 #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include <iterator> #pragma warning (disable : 26495) template<typename T> class linklist{ public: using uint = unsi...
智能指针、共享指针
z594346047的博客
11-18 137
默认情况下，shared_ptr指向的动态的内存是使用delete来删除的。shared_ptr 默认的构造函数中使用的是delete来删除关联的指针，所以构造的时候也必须使用new出来的堆空间的指针。对于申请的动态数组来说，shared_ptr 指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存。:就是记录对象被引用的次数，当引用次数为 0 的时候，也就是最后一个指向该对象的共享指针析构的时候，共享指针的析构函数就把指向的内存区域释放掉。跟get函数一样的效果。
【C++ STL】 --- list
M2嵌入式
08-30 332
1、list基本概念 功能：将数据进行链式存储 链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 STL中的链表是一个双向循环链表 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器 list的优点： 采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即
学生管理系统（C++，控制台，文件读取，姓名排序）
热门推荐
李子的博客
08-19 1万+
这是一个用C++写的控制台程序，利用简单的菜单实现学生信息的管理。简图如下所示： 菜单栏： 查询数据： 修改数据： 打印数据： 以下是添加了一些学生信息的进行一些操作的结果： 除了上面所展示的功能以外，还可以将所有的学生信息保存到一个txt文件中，或者将一个文件里面的学生信息读取进来，当
链表（Linked List）的C语言实现
乘风破浪会有时
08-20 7110
链表中的各对象按线性顺序排列，而其顺序是由各个对象里的指针所决定的。 链表有多种形式，它可以是单链接的或者双链接的，可以是已排序的或未排序的，可以是循环的或非循环的。 定义的结构体以及函数如下：typedef struct ITEM { int key; void * statellite; } item_t; typedef struct NODE { struct N
c++ 数据结构 链表类（详解）
weixin_59629651的博客
09-28 1758
大学课 链表 数据结构 c++
数据结构 带头结点的单链表 操作大全 最全的链表操作（c++实现）
09-27
1800多行代码 22个功能 最全的链表操作 如需转载请注明出处 我的博文：http://blog.csdn.net/u012350104 欢迎交流 讲解代码中函数的ppt：http://download.csdn.net/detail/u012350104/9143181 Made By Fred韩
数据结构算法集---C++语言实现.rar_queue stack_堆栈 栈_数据结构 队列_链表_队列
07-15
链表（Linked List）是另一种重要的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。与数组相比，链表在插入和删除操作上具有优势，但访问...
Doubly-linked-list.rar_数据结构_Visual_C++_
08-12
双向链表是一种特殊的数据结构，属于线性数据结构的一种，它在实际编程中有着广泛的应用，尤其是在C++这样的面向对象编程语言中。本项目“Doubly-linked-list.rar”显然是一个关于双向链表的实践教程，通过Visual ...
C++数据结构实现之Linkedlist.zip
06-04
在这个"C++数据结构实现之Linkedlist.zip"压缩包中，我们可以预见到包含的是关于C++实现链表（Linked List）的详细教程或代码示例。 链表是一种线性数据结构，与数组不同，它不连续存储元素。链表由一系列节点组成...
intSLList.rar_数据结构_C++_Builder_
08-12
**标题解析：** "intSLList.rar" 是一个压缩包文件，名字暗示它包含了一个关于整型单链表（Integer Singly Linked List）的数据结构实现。"C++" 指出使用的编程语言是C++，而 "_Builder_" 可能意味着这个实现是为 ...
C++链表（linked list）
qq_31617961的博客
08-31 2130
基础知识 链表也是一种线性表。链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。 插入、删除数据效率O(1)级别（只需更改指针指向即可），随机访问效率O(n)级别（需要从链头至链尾进行遍历）。此外和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储指针。 常用链表： 单链表：每个节点只包含一个指针，即后继指针。首节点地址表示整条链表，尾节点的后继指针指向空地址null 循环链表：除了尾节点的后继指针指向首节点的...
C++基础数据结构 | 链表（linked list）
小麦China的博客
04-22 146
C++基础数据结构 | 链表（linked list） 206. 反转链表 92. 反转链表 II 25. K 个一组翻转链表 复用92. 链表 II 2. 两数相加 carry位加一 445. 两数相加 II 栈，carry位加一 21. 合并两个有序链表 23. 合并K个升序链表 d...
C++ single linked list 单链表的创建和执行（有头尾节点，考虑动态存储和内存泄漏等问题）（1）
shuoO-24的空间站
02-26 441
这是C++ programming II这门课布置的一个小作业，核心是关于动态存储和指针的理解（尤其是new和delete的使用）；花了不少时间，中途来csdn找资料也没有看到相关内容的经验分享，所以来写篇博文记录一下成果和心得。 代码旁有简单的注释，中英夹杂；不重要的我没有翻译，有问题的话欢迎评论留言。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值