C++类实现双链表

最新推荐文章于 2024-04-29 11:56:38 发布
最新推荐文章于 2024-04-29 11:56:38 发布
阅读量380 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 数据结构 程序设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ACDSee9/article/details/129869041
版权

先直接上代码：

#include <iostream>

using std::cout;
using std::endl;

struct Node {
	Node(int data = 0, Node *pre = nullptr, Node *next = nullptr)
		: _data(data)
		, _pre(pre)
		, _next(next) {
		cout << "Node(int  = 0, Node * = nullptr, Node * = nullptr) " << endl;
	}

	~Node() {
		cout << "~Node()" << endl;
	}
	int _data;
	Node *_pre;
	Node *_next;
};

class List {
	public:
		List()
			: _head(new Node())
			, _tail(new Node())
			, _size(0) {
			cout << "List()" << endl;
			_head->_next = _tail;
			_tail->_pre = _head;
		}
		//在头部进行插入
		void push_front(int data) {
			Node *newNode = new Node(data);
			newNode->_pre = _head;
			newNode->_next = _head->_next;
			_head->_next->_pre = newNode;
			_head->_next = newNode;

			++_size;
		}
		//在尾部进行插入
		void push_back(int data) {
			Node *newNode = new Node(data);
			newNode->_pre = _tail->_pre;
			newNode->_next = _tail;
			_tail->_pre->_next = newNode;
			_tail->_pre = newNode;

			++_size;

		}

		//在头部进行删除
		void pop_front() {
			if (size() > 0) {
				Node *pNode = _head->_next;
				pNode->_next->_pre = _head;
				_head->_next = pNode->_next;

				delete pNode;
				pNode = nullptr;
				--_size;
			} else {
				cout << "该链表为空，无法删除"  << endl;
				return;
			}
		}
		//在尾部进行删除
		void pop_back() {
			if (size() > 0) {
				Node *pNode = _tail->_pre;
				pNode->_pre->_next = _tail;
				_tail->_pre = pNode->_pre;

				delete pNode;
				pNode = nullptr;
				--_size;
			} else {
				cout << "该链表为空，无法删除"  << endl;
				return;
			}
		}

		//在中间进行插入
		void insert(int pos, int data) {
			if (pos < 0 || pos > size()) {
				cout << "该位置异常，无法插入" << endl;
				return;
			}

			Node *pNode = _head;
			while (pos-- > 0) {
				pNode = pNode->_next;
			}

			Node *newNode = new Node(data);
			newNode->_pre = pNode;
			newNode->_next = pNode->_next;
			pNode->_next->_pre = newNode;
			pNode->_next = newNode;

			++_size;
		}

		//在中间进行删除
		void erase(int data) {
			bool flag = find(data);
			if (flag) {
				Node *pNode = _head->_next;
				while (pNode && pNode != _tail) {
					if (pNode->_data == data) {
						Node *ptmp = pNode->_pre;
						pNode->_next->_pre = ptmp;
						ptmp->_next = pNode->_next;

						delete pNode;
						pNode = nullptr;
						--_size;

						pNode = ptmp;
					}
					pNode = pNode->_next;
				}
			} else {
				cout << "该元素不在链表之中，无法删除" << endl;
				return;
			}
		}

		bool find(int data) {
			if (size() > 0) {
				Node *pNode = _head->_next;
				while (pNode && pNode != _tail) {
					if (data == pNode->_data) {
						return true;
					}
					pNode = pNode->_next;
				}

				return false;
			} else {
				cout << "该链表为空，无法查找"  << endl;
				return false;
			}
		}

		void display() const {
			if (size() > 0) {
				Node *pNode = _head->_next;
				while (pNode && pNode != _tail) {
					cout << pNode->_data << "  ";
					pNode = pNode->_next;
				}
				cout << endl;
			} else {
				cout << "该链表为空，无法打印" << endl;
				return;
			}
		}
		~List() {
			cout << "~List()" << endl;
			Node *deleteNode = _head->_next;
			while (deleteNode) {
				Node *ptmp = deleteNode->_next;
				delete deleteNode;
				deleteNode = nullptr;
				deleteNode = ptmp;
			}
			delete _head;
			_head = nullptr;
		}

		int size() const {
			return _size;
		}
	private:
		Node *_head;
		Node *_tail;
		int _size;
};
int main(int argc, char **argv) {
	List lst;
	lst.display();

	cout << endl << "在链表头部进行插入 :" << endl;
	lst.push_front(1);
	lst.push_front(3);
	lst.push_front(5);
	lst.display();

	cout << endl << "在链表尾部进行插入 :" << endl;
	lst.push_back(11);
	lst.push_back(33);
	lst.push_back(55);
	lst.display();

	cout << endl << "在链表头部进行删除 :" << endl;
	lst.pop_front();
	lst.display();

	cout << endl << "在链表尾部进行删除 :" << endl;
	lst.pop_back();
	lst.display();

	cout << endl << "查找元素 :" << endl;
	/* bool flag = lst.find(100); */
	bool flag = lst.find(11);
	cout << "flag = " << flag << endl;

	cout << endl << "在中间进行插入" << endl;
	/* lst.insert(10, 100); */
	lst.insert(2, 100);
	lst.display();

	cout << endl << "在中间进行删除" << endl;
	lst.erase(11);
	lst.display();
	return 0;
}

该方式模仿STL List容器的实现，但仅支持int数据类型，引入模板后可支持泛型。

需要注意的点为：当调用类的构造函数创建对象时，默认会创建头结点为尾结点，但头结点和尾结点不存储数据，这两个节点用于头插尾插头删尾删的定位操作。

代码解析

struct Node部分

struct Node {
	Node(int data = 0, Node *pre = nullptr, Node *next = nullptr)
		: _data(data)
		, _pre(pre)
		, _next(next) {
		cout << "Node(int  = 0, Node * = nullptr, Node * = nullptr) " << endl;
	}

	~Node() {
		cout << "~Node()" << endl;
	}
	int _data;
	Node *_pre;
	Node *_next;
};

在C++中对结构体的功能做了增强，支持构造函数，该函数用于初始化对象。以上代码是双链表的数据类型定义和新结点的初始化操作。在C++中struct就是定义类的关键字，其默认访问权限为public，与之对应的定义类的关键字为class，class的默认访问权限为private.

List类部分

构造函数

List()
	: _head(new Node())
	, _tail(new Node())
	, _size(0) {
	cout << "List()" << endl;
	_head->_next = _tail;
	_tail->_pre = _head;
}

该函数的作用用于创建类对象和初始化数据成员，_head->_next = _tail;
_tail->_pre = _head;两行代码用于创建两个头结点为尾结点，其中头结点和尾结点不带数据，中间插入的节点带数据。

析构函数

~List() {
		cout << "~List()" << endl;
		Node *deleteNode = _head->_next;
		while (deleteNode) {
			Node *ptmp = deleteNode->_next;
			delete deleteNode;
			deleteNode = nullptr;
			deleteNode = ptmp;
		}
		delete _head;
		_head = nullptr;
	}

析构函数的作用用于销毁对象的数据成员，从头结点的下一个结点开始遍历采用带头尾节点的双链表，每次有一个指针保存当前节点的下一个结点，删除当前结点，再将当前结点的下一个结点置为当前结点，依次循环删除，直到只剩下头结点，最后删除头结点即完成链表的销毁操作。该双链表每次开辟结点在堆申请空间，销毁链表时需要手动释放，否则造成内存泄漏（即分配完以后未释放，造成该片已分配的空间无法再次使用）。

头插push_front()

//在头部进行插入
void push_front(int data) {
	Node *newNode = new Node(data);
	newNode->_pre = _head;
	newNode->_next = _head->_next;
	_head->_next->_pre = newNode;
	_head->_next = newNode;

	++_size;
}

尾插

//在尾部进行插入
void push_back(int data) {
	Node *newNode = new Node(data);
	newNode->_pre = _tail->_pre;
	newNode->_next = _tail;
	_tail->_pre->_next = newNode;
	_tail->_pre = newNode;

	++_size;

}

头部删除和尾部删除同理

从头遍历链表

void display() const {
	if (size() > 0) {
		Node *pNode = _head->_next;
		while (pNode && pNode != _tail) {
			cout << pNode->_data << "  ";
			pNode = pNode->_next;
		}
		cout << endl;
	} else {
		cout << "该链表为空，无法打印" << endl;
		return;
	}
}

从尾部开始遍历的链表逻辑相似，把指针定位到尾指针的前一个位置，每次往前移动，遇到头指针停止

判断指定的元素是否存在（查找）

bool find(int data) {
	if (size() > 0) {
		Node *pNode = _head->_next;
		while (pNode && pNode != _tail) {
			if (data == pNode->_data) {
				return true;
			}
			pNode = pNode->_next;
		}

		return false;
	} else {
		cout << "该链表为空，无法查找"  << endl;
		return false;
	}
}

该函数仅用于确定存在性，而不返回元素的具体位置

从任意位置插入元素

//在中间进行插入
void insert(int pos, int data) {
	if (pos < 0 || pos > size()) {
		cout << "该位置异常，无法插入" << endl;
		return;
	}

	Node *pNode = _head;
	while (pos-- > 0) {
		pNode = pNode->_next;
	}

	Node *newNode = new Node(data);
	newNode->_pre = pNode;
	newNode->_next = pNode->_next;
	pNode->_next->_pre = newNode;
	pNode->_next = newNode;

	++_size;
}

先判断插入位置是否合法，若不合法则直接return，若合法则找插入位置，找到插入位置后插入元素

从任意位置删除元素

//在中间进行删除
void erase(int data) {
	bool flag = find(data);
	if (flag) {
		Node *pNode = _head->_next;
		while (pNode && pNode != _tail) {
			if (pNode->_data == data) {
				Node *ptmp = pNode->_pre;
				pNode->_next->_pre = ptmp;
				ptmp->_next = pNode->_next;

				delete pNode;
				pNode = nullptr;
				--_size;

				pNode = ptmp;
			}
			pNode = pNode->_next;
		}
	} else {
		cout << "该元素不在链表之中，无法删除" << endl;
		return;
	}
}

先判断删除的位置是否合法，若不合法则退出，若合法则删除对应元素。

测试效果图：在这里插入图片描述
进一步优化的建议：可以将find函数返回一个具体的数值，用于记录目标元素的位置，根据双链表的特性，判断元素位置和_size/2的大小。若小于可从头开始增删元素，若大于则从尾开始增删元素。

林毅夫
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 实现双向链表的实例
12-31
双向链表C++ 的实现                    本文是通过C++ 的知识实现数据结构中的双向链表，这里不多说 了，代码注释很清楚， 实现代码： //double LinkList implement with C++ template #include<iostream> using namespace std; /*template<typename> class DBListADT { public: virtual void Append(const Type &)=0; virtual void Insert(const
双向链表（c++实现）
echo_bright_的博客
02-02 4100
单向链表的缺点：逆序访问单向链表中的数据元素，效率低下。   若从头节点开始依次访问单向链表的元素，可使用m_current游标，但是逆序访问，只能通过下面代码实现访问： int main(void) { LinkListint> ll; for (int i = 0; i 6; ++i) //O(n) { ll.insert(0, i); }
C++实现双向链表
m0_56157939的博客
04-19 361
C++实现双向链表，具有基本的功能
双向链表实现(c/c++)
qq_52095705的博客
11-16 2131
前言 数据结构还是得来一手。 一.关于链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。链表通过指针域能把多个元素串联起来。 一般的链表中每个元素只有一个指向下一个元素的指针域，而我们的双向链表却有两个指针域，其中一个指针域指向下一个元素，另一个指针域指向这个元素的上一个元素。 接下来看程序
C++实现双向循环链表
12-20
本文实例为大家分享了C++实现双向循环链表的具体代码，供大家参考，具体内容如下 一、概念 1.在双链表中的每个结点应有两个链接指针：  lLink -> 指向前驱结点  （前驱指针或者左链指针） rLink->指向后继结点（后驱指针或者右链指针） 2.双链表常采用带附加头结点的循环链表方式： first：头指针，不存放数据，或者存放特殊要求的数据。它的lLink指向双链表的尾结点（最后一个结点）， 它的rLink指向双链表的首结点（第一个有效结点）。链表的首结点的左链指针lLink和尾结点的右链指针 rLink都指向附加头结点。 二、实现程序 1.DblList.h #ifndef DblL
C++实现双链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-04 2421
双链表节点由存储的数据、指向前一个元素的指针和指向后一个元素的指针构成，因此双联表节点的代码也很容易得到，如下： 双链表和单链表类似，也需要添加、删除和查找。 1、插入操作 插入的情况说明：插入每次都在第一个位置插入，也就是在伪头节点（不含元素）后插入。插入节点的过程：插入的代码逻辑： 2、删除操作 将目标节点的下一个节点的指针指向目标节点的前一个节点（目标节点下一个节点不存在则省略） 将目标节点的前一个节点的指针指向目标节点的下一个节点 代码逻辑： 3、查找操作 不同于单链表，双链表查找直接返回目
使用C++实现双链表
qq_58240448的博客
07-01 3018
c++实现的双链表
数据结构——C++中实现双链表（含完整代码）
huaimaisui的博客
07-10 2658
双链表相关代码。 1、创建双链表(-1结束) 2、遍历双链表 3、插入双链表元素 4、双链表删除元素 5、判断双链表是否为空 6、双链表的长度 7、查找双链表元素 0、退出程序 纯手打，亲测可以运行，使用自取。............
C++ 手动实现双向链表（作业版）
a1367666195的博客
11-22 719
手动实现双向链表，包含增删查改功能，附源码
C++的双向链表实现
04-15
代码基于标准C++，可以用vscode，vs，qt等IDE打开。具备基本的双链表操作，如头插尾插，前驱遍历和后继遍历，求长度等等。
c++语言实现双向循环链表
08-03
c++语言实现双向循环链表
C++实现双向链表（List）
08-19
主要为大家详细介绍了C++实现双向链表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于C++的双链表实现
03-28
实现功能： void CreateList(T a[], int n); // 由a数组中的元素建造顺序表 void DispList(); // 输出顺序表L中的所有元素 int ListLength(); // 求顺序表的长度 bool GetElem(int i, T &e); // 求顺序表中某序列号的元素值 int LocateElem(T e); // 按元素查找其第一个序号位置 bool ListInsert(int i, T e); // 在位置i插入数据元素e bool ListDelete(int i); // 在位置i删除数据元素 void ReverseList(SqListClass &L); // 翻转顺序表
【C++第三阶段】list容器&排序
最新发布
还有很多需要学习，现在还很菜
04-29 668
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 271
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1067
C++ Primer (第五版）第八章习题部分答案
c入门基础题（3）
梦昼初
04-26 962
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
如何在c++中实现双向链表
06-01
2. 定义双向链表类，包括头节点和尾节点指针，以及一些基本的操作方法，如插入节点、删除节点、查找节点等。 ```c++ class DoublyLinkedList { public: DoublyLinkedList() : head(nullptr), tail(nullptr) {} ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值