双链表的实现C++封装

最新推荐文章于 2019-10-28 22:41:50 发布
最新推荐文章于 2019-10-28 22:41:50 发布
阅读量728 收藏 3
点赞数
分类专栏： 数据结构 C++学习之路 数据结构基础算法 文章标签： 双链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J_Anson/article/details/48877645
版权

双链表的C++实现，先给出主要算法，最后而给出完整的实现。

定义节点

//定义节点
typedef class Node
{
public:
	//数据
	int data;
	//前指针
	class Node *prior;
	//后指针
	class Node *next;
}ListNode;

头插法插入元素节点 

	//创建并初始化（头插法）
	List(int a[], int n){
		int i;
		ListNode *p;
		L = (ListNode *)malloc(sizeof(ListNode));
		L->next = L->prior = NULL;
		for (i = 0; i < n; i++){
			p = (ListNode *)malloc(sizeof(ListNode));
			p->data = a[i];
			p->next = L->next;//将p后一个节点地址赋给l->next
			if (L->next != NULL){
				L->next->prior = p;//将L后一节点的前指针赋值为带插入指针地址
			}
			p->prior = L;//带插入前指针赋值为L
			L->next = p;//L后指针赋值为p
		}
	}

尾插法插入节点 

	//尾插法
	List(int a[], int n){
		int i;
		ListNode *p, *s;
		//初始化表头
		L = (ListNode *)malloc(sizeof(ListNode));
		L->prior = NULL;
		//使p指向尾节点，初始时头结点即为尾节点
		p = L;
		//生成新节点，插入元素，链上节点
		for (i = 0; i < n; i++){
			s = (ListNode *)malloc(sizeof(ListNode));
			s->data = a[i];
			//前指针指向尾结点
			s->prior = p;
			//尾指针指向新节点
			p->next = s;
			//将新节点变成为节点
			p = s;
		}
		p->next = NULL;
	}
释放双 链表 

//析构并释放空间
	~List(){
		ListNode *pre = L, *p = L->next;
		while (p != NULL){
			free(pre);
			pre = p;
			p = pre->next;//p指向下下个节点
		}
		free(pre);//下个节点
	}

判断是否为空 

	//判断是否为空
	bool isEmpty(){
		return (L->next == NULL);
	}
返回链表长度 

	//返回长度
	int GetLength(){
		int i = 0;
		ListNode *p = L;
		while (p->next != NULL){//p->next为当前节点的指针域
			i++;
			p = p->next;
		}
		return i;
	}
输出链表元素 

	//输出链表
	void DispleyList(){
		ListNode *p = L->next;
		while (p != NULL){
			cout << p->data << ends;
			p = p->next;
		}
		cout << endl;
	}
按元素位置查找并返回值 
	//按序号查找并返回值
	bool getElem(int i, int &res){
		ListNode *p = L;
		int j = 0;
		while (j != i&&p->next != NULL){
			j++;
			p = p->next;
		}
		//讨论退出的情况
		if (j != i&&p->next == NULL){
			return false;
		}
		else{
			res = p->data;
			return true;
		}
	}
按值查找并返回位置 
	//按值查找并返回序号
	int LocateElem(int elem){
		ListNode *p = L;
		int i = 0;
		while (p->next != NULL&&p->data!=elem){
			i++;
			p = p->next;
		}
		//讨论退出的情况
		if (p->next == NULL&&p->data != elem){
			return 0;
		}
		else{
			return i;
		}
	}
插入新节点 

	//插入元素
	void InsertElem(int i, int &res){
		i--;//找到插入位置的前一个节点
		int j = 0;
		ListNode *p = L, *s;
		while (j != i&&p->next != NULL){
			j++;
			p = p->next;
		}
		//讨论退出情况
		if (j != i&&p->next == NULL){
			cout << "error No." << endl;
		}
		else{
			s = (ListNode *)malloc(sizeof(ListNode));
			s->data = res;
			//链上后继节点，当前节点的指针域赋值为p的后继节点
			s->next = p->next;
			//插入当前节点，下一节点的前指针指向当前节点
			p->next->prior = s;
			//p的后指针域赋值为当前节点
			p->next = s;
			//当前节点的前指针赋值为p
			s->prior = p;
		}
	}
删除某一节点 

	//删除元素并返回值
	bool DeleteElem(int i,int &res){
		i--;
		ListNode *p = L, *s;
		int j = 0;
		while (j != i&&p->next != NULL){
			j++;
			p = p->next;
		}
		if (j != i&&p->next == NULL){
			return false;
		}
		else{
			//记录p的下一个节点的地址
			s = p->next;
			//得到数据
			res = s->data;
			//p的后指针域存储p的下一个的下一个节点
			p->next = p->next->next;
			//p的下一个的下一个节点的前指针域赋值为p的地址
			p->next->next->prior = p;
			//释放
			free(s);
			return true;
		}
	}

以上便是完整的双链表算法C++实现，下面附上完整代码 

#include<iostream>
using namespace std;
const int MAX_N = 100;
//定义节点
typedef class Node
{
public:
	//数据
	int data;
	//前指针
	class Node *prior;
	//后指针
	class Node *next;
}ListNode;

class List
{
public:
	//创建并初始化（头插法）
	//List(int a[], int n){
	//	int i;
	//	ListNode *p;
	//	L = (ListNode *)malloc(sizeof(ListNode));
	//	L->next = L->prior = NULL;
	//	for (i = 0; i < n; i++){
	//		p = (ListNode *)malloc(sizeof(ListNode));
	//		p->data = a[i];
	//		p->next = L->next;//将p后一个节点地址赋给l->next
	//		if (L->next != NULL){
	//			L->next->prior = p;//将L后一节点的前指针赋值为带插入指针地址
	//		}
	//		p->prior = L;//带插入前指针赋值为L
	//		L->next = p;//L后指针赋值为p
	//	}
	//}
	//尾插法
	List(int a[], int n){
		int i;
		ListNode *p, *s;
		//初始化表头
		L = (ListNode *)malloc(sizeof(ListNode));
		L->prior = NULL;
		//使p指向尾节点，初始时头结点即为尾节点
		p = L;
		//生成新节点，插入元素，链上节点
		for (i = 0; i < n; i++){
			s = (ListNode *)malloc(sizeof(ListNode));
			s->data = a[i];
			//前指针指向尾结点
			s->prior = p;
			//尾指针指向新节点
			p->next = s;
			//将新节点变成为节点
			p = s;
		}
		p->next = NULL;
	}
	//析构并释放空间
	~List(){
		ListNode *pre = L, *p = L->next;
		while (p != NULL){
			free(pre);
			pre = p;
			p = pre->next;//p指向下下个节点
		}
		free(pre);//下个节点
	}
	//判断是否为空
	bool isEmpty(){
		return (L->next == NULL);
	}
	//返回长度
	int GetLength(){
		int i = 0;
		ListNode *p = L;
		while (p->next != NULL){//p->next为当前节点的指针域
			i++;
			p = p->next;
		}
		return i;
	}
	//输出链表
	void DispleyList(){
		ListNode *p = L->next;
		while (p != NULL){
			cout << p->data << ends;
			p = p->next;
		}
		cout << endl;
	}
	//按序号查找并返回值
	bool getElem(int i, int &res){
		ListNode *p = L;
		int j = 0;
		while (j != i&&p->next != NULL){
			j++;
			p = p->next;
		}
		//讨论退出的情况
		if (j != i&&p->next == NULL){
			return false;
		}
		else{
			res = p->data;
			return true;
		}
	}
	//按值查找并返回序号
	int LocateElem(int elem){
		ListNode *p = L;
		int i = 0;
		while (p->next != NULL&&p->data!=elem){
			i++;
			p = p->next;
		}
		//讨论退出的情况
		if (p->next == NULL&&p->data != elem){
			return 0;
		}
		else{
			return i;
		}
	}
	//插入元素
	void InsertElem(int i, int &res){
		i--;//找到插入位置的前一个节点
		int j = 0;
		ListNode *p = L, *s;
		while (j != i&&p->next != NULL){
			j++;
			p = p->next;
		}
		//讨论退出情况
		if (j != i&&p->next == NULL){
			cout << "error No." << endl;
		}
		else{
			s = (ListNode *)malloc(sizeof(ListNode));
			s->data = res;
			//链上后继节点，当前节点的指针域赋值为p的后继节点
			s->next = p->next;
			//插入当前节点，下一节点的前指针指向当前节点
			p->next->prior = s;
			//p的后指针域赋值为当前节点
			p->next = s;
			//当前节点的前指针赋值为p
			s->prior = p;
		}
	}
	//删除元素并返回值
	bool DeleteElem(int i,int &res){
		i--;
		ListNode *p = L, *s;
		int j = 0;
		while (j != i&&p->next != NULL){
			j++;
			p = p->next;
		}
		if (j != i&&p->next == NULL){
			return false;
		}
		else{
			//记录p的下一个节点的地址
			s = p->next;
			//得到数据
			res = s->data;
			//p的后指针域存储p的下一个的下一个节点
			p->next = p->next->next;
			//p的下一个的下一个节点的前指针域赋值为p的地址
			p->next->next->prior = p;
			//释放
			free(s);
			return true;
		}
	}
private:
	ListNode *L;
};
int main(){
	int i, n, a[MAX_N], res = 0;
	cout << "Input length:";
	cin >> n;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	//构建单链表
	List m_list(a, n);
	//输出
	m_list.DispleyList();
	//判断是否为空，非空输出长度
	if (!m_list.isEmpty()){
		cout << "It is not empty." << endl;
		cout << "It contained " << m_list.GetLength() << " elements." << endl;
	}
	else{
		cout << "It is empty." << endl;
	}
	//按序号查找并返回值
	cout << "Input a number for querry:";
	cin >> i;
	if (m_list.getElem(i, res)){
		cout << "Location: " << i << " ,element: " << res << endl;
	}
	else{
		cout << "Loaction " << i << " is invalid." << endl;
	}
	//按值查找并返回序号
	cout << "Input a element for querry:";
	cin >> res;
	if (m_list.LocateElem(res) == 0){
		cout << "Not contain this element." << endl;
	}
	else{
		cout << "Element: " << res << " ,No. is :" << m_list.LocateElem(res) << endl;
	}
	//插入
	cout << "Input NO. and element for insert:";
	cin >> i >> res;
	m_list.InsertElem(i, res);
	m_list.DispleyList();
	//删除
	cout << "Input NO. for delete:";
	cin >> i;
	if (!m_list.DeleteElem(i, res)){
		cout << "Invalid NO." << endl;
	}
	else{
		cout << "NO. :" << i << " ,Element: " << res << " is deleted." << endl;
	}
	m_list.DispleyList();
	return 0;
}

测试运行结果







J_Anson
关注
专栏目录
双链表C++封装
04-13
用命令行的C++链表封装了的，实现功能完善，健壮性良好
呵呵
嵌入式Developer_小J的天空
01-29 642
android开发中常用的Eclipse快捷键详细整理方便查找,需要的朋友可以了解下       Eclipse快捷键-方便查找，呵呵，记性不好        行注释/销注释 Ctrl+/ 块注释/销注释/XML注释 Ctrl+Shift+/ Ctrl+Shift+\        查找 查找替换 Ctrl+H Ctrl+F        查找下一个/往回找 Ctrl+K Ctrl+S
双向链表的封装
03-24 130
#include<iostream>typedef int DataType;typedef int Status;typedef struct DNode{ DataType data; struct DNode *Next; struct DNode *Prior;}DNode,*DoubleList;#define TRUE 1#define...
双向链表（c++封装）
dove1202ly的博客
10-21 567
双向链表是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。结构图如下所示：其中_pPre是双向链表的前驱结点，_pNext是它的后继结点，_data是数据域 代码实现：#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> #include<ass
C++实现双链表的基本功能
微风
08-23 5910
双链表：在单链表的每个结点中，再设置一个指向其前驱结点的指针域 线性表的双向链表存储结构： typedef struct Node { DataType _data; struct Node *_next; struct Node *_front; }Node;   通过双链表的存储结构我们发现双链表可以反向查找结点优于单链表 ，实质上双链表就是以
数据结构 双向链表（C++）
06-07
在C++中，我们可以创建一个类来封装双向链表的管理。这个类通常包含指向头节点和尾节点的指针，以及一些基本操作的成员函数： ```cpp class DoublyLinkedList { private: Node* head; Node* tail; public: ...
C++实现双向链表
08-19
本文将详细介绍如何使用C++实现一个双向链表，并提供相关的操作方法。 首先，我们定义一个结构体`ListNode`来表示链表中的节点。每个`ListNode`对象都有三个成员变量： 1. `ListNode* _next`：存储指向下一个节点...
C++实现双向链表（完整代码）
05-10
本文将深入探讨双向链表及其C++实现，适合初学者学习和实践。 双向链表是一种线性数据结构，每个节点包含数据部分和两个指针，一个指向前一个节点（prev），另一个指向后一个节点（next）。与单向链表不同，双向...
C++实现电话薄(双链表)
04-12
本项目“C++实现电话薄(双链表)”旨在通过使用双链表来构建一个简单的电话簿系统，这在控制台应用程序中尤为常见。下面将详细介绍双链表以及如何用C++实现电话簿功能。 双链表是一种线性数据结构，每个节点包含两个...
用双链表封装的栈的实现
互联网
03-27 113
上一篇文章http://blog.csdn.net/hongkangwl/article/details/22286469中用C++实现了双向链表了，下面我们对其封装，得到栈~~ 、 我们用链表的插入和删除模仿pop和push 完整代码如下： #include &lt;iostream&gt; using namespace std; struct node { int date; ...
类链表的简单实现
人间有味是清欢
04-19 6427
刚学完类和对象，做了个简单的类指针，有插入和遍历的功能，没有删除。类里有四个数据成员：data（用在判断函数），number（学号），name（姓名），*next（指针）。 两个成员函数：输入和输出函数。 有三个函数：judge（判断函数）、create（建立结点的函数）、show（遍历函数）。#include<iostream> using namespace std;
反转链表
茜茜公主的专栏
08-03 638
好久没有进blog了，最近看了好多找工作时的面试题，现在来分享下题目：输入一个链表的头结点，从尾到头反过来输出每个结点的值。链表结点定义如下：struct ListNode{      int       m_nKey;      ListNode* m_pNext;}; 看到这道题后，第一反应是从头到
线性表的链式存储
天道酬勤的博客
10-28 489
线性表的顺序存储的特点是，在逻辑关系上相邻的两个元素在物理位置上也是相邻的，因此可以随机存取表中任一元素。但是，当经常做插入和删除操作运算时，则需要移动大量的元素，而采用链式存储结构就可以避免这些移动。 用C语言中的结构类型描述线性表的链式存储结构如下： typedef struct node{ Datatype data; struct node *next; }ListNod...
c语言实现双向链表
wu1217的博客
09-05 4451
/** 双链表操作 开发环境codeblocks12.11 xxwu */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode{     ElemType data;     struct DNode ...
实现通用的双向链表（c语言实现）
echo_bright_的博客
10-16 8312
国庆8天在家阅读李先静大神的书籍，抽空把一些笔记记录下来。从实现一个通用的双向链表开始。 1. 构建链表节点   链表节点存值还是存值的地址(指针)？对于通用链表首先要做到能够存放任何数据类型的数据，首先可能会想到的是union，但是数据类型无穷无尽，不可能在union中全部表示。那么可行的办法有两种：   (1) 存值 typedef struct _DListNode DLis
哈夫曼树及哈夫曼编码 C++
热门推荐
J.Anson的博客
01-02 1万+
用C++实现哈夫曼树以及哈夫曼编码。 代码说明： 1.读取文件中需进行哈夫曼编码的数据信息 2.构造生成单节点二叉树组 -> 森林 3.构造哈夫曼树 4.进行哈夫曼编码 5.输出对应数据及其编码
稀疏矩阵的实现（三元组存储）C++
J.Anson的博客
11-17 8161
通过三元组存储稀疏矩阵，压缩存储空间，实现存储稀疏矩阵，遍历输出等操作。
二叉树的基本操作C++
J.Anson的博客
11-17 8062
二叉树实现 1.创建二叉树 2.递归输出二叉树 2.1递归先序输出 2.2递归中序输出 2.3递归后序输出 3.非递归输出 3.1非递归先序输出 3.2非递归中序输出 3.3非递归后序输出 4.层次遍历二叉树 5.求树高 6.求树叶子节点 7.按值查找对应节点，输出左孩子结点值和右孩子结点值 8.计算所有节点数
二叉树的实现（递归遍历和非递归遍历）C++
J.Anson的博客
11-06 6671
二叉树的操作，使用栈构建一棵二叉树，然后求树高，递归先序遍历，中序遍历，后序遍历，访问左节点，访问右节点，非递归先序遍历输出，非递归中序遍历输出，非递归后序遍历输出。
C++实现循环链表与双向链表API详解
"深入解析C++的循环链表与双向链表设计的API实现，包括创建、销毁、获取长度、清空、元素操作以及游标的使用，适用于理解和实践链表数据结构" 在C++中，循环链表是一种特殊形式的单链表，其中最后一个节点的next...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值