数据结构之——双向链表完备版（C++实现）

最新推荐文章于 2023-03-17 16:18:23 发布
最新推荐文章于 2023-03-17 16:18:23 发布
阅读量392 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GaoXiaoYuan0728/article/details/107784195
版权

双向链表

双向链表

⚪接口设计

        双向链表和单向链表对应的接口无太多差别，只是在节点类中添加了prev指针和在链表类中添加了last尾指针

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


template<class E>
class Node
{
public:
	E element;
	Node<E>* next;
	Node<E>* prev;
	Node(Node<E>* prev, E element, Node<E>* next)
	{
		this->element = element;
		this->next = next;
		this->prev = prev;
	}
	~Node() {}
};

template<class E>
class Circle_DouLinkList
{
private:
	int size;
	Node<E>* first = NULL;
	Node<E>* last = NULL;

	static const int ELEMENT_NOT_FOUND = -1;

	Node<E>* find_node(int index);
public:
	void clear();
	void add(E element);
	void add(int index, E element);
	int Size();
	int indexOf(E element);
	bool isEmpty();
	bool contains(E element);
	E get(int index);
	E set(int index, E element);
	E remove(int index);
	void print();

	~Circle_DouLinkList(){}
};

⚪难点讲解

①添加元素void add(int index, E element);

因为涉及头节点和尾节点，所以要分中间、头、尾三种情况来讨论

1、中间

      假设在位置2处添加元素中间添加元素
        首先将添加位置2节点的前一个节点1处的next指针指向新元素，因为存在prev指针，所以不需要再像单向链表中一样再去找前一个节点，只需要通过结点2的prev指针就可以找到前一个节点。然后将节点2的prev指针指向新元素。最后将所添加节点的prev指针指向节点1，next指针指向节点2。效果如下图所示。
中间添加元素

Node<E>* next = find_node(index);
Node<E>* prev = next->prev;
Node<E>* p = new Node<E>(prev, element, next);
prev->next = p;
next->prev = p;
2、头部

        由于前面的代码设计的prev指针，所以要考虑prev指针为空的情况，即在头节点添加元素。因此我们要加上对于在头节点添加元素的讨论。
头部添加

Node<E>* next = find_node(index);		//0
Node<E>* prev = next->prev;				//NULL
Node<E>* p = new Node<E>(prev, element, next);
next->prev = p;
if (prev == NULL)		//如果index==0
{
	first = p;
}
else
{
	prev->next = p;
}

        与上面在中间节点添加元素是一个思路，只需在在对于prev的操作进行一个讨论，前面的代码可以共用。将往节点0处添加节点为例子 。
        第一句代码next指针 获得的是节点0 ，第二句代码prev指针获得的是节点0的前一个节点，便是NULL。然后将prev,element,next分别赋值给新节点p,等价于Node* p = new Node(NULL, element, 0)，然后将next指针即节点0的prev指向新节点，最后判断prev节点是否为空，即是否插入在头部，如果是在头部就将头指针指向新节点。
头节点插入

3、尾部
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;由于还存在尾节点，因此我们仍需要对于尾节点的情况进行讨论

尾部添加
        首先要将尾节点指向新添加的元素顺便将新元素构造出来。新添加节点的prev指针就是之前的尾指针，next指针就是NULL指针。

last = new Node<E>(last, element, NULL);

尾部添加
        最后只剩下之前的尾节点的next指针指向新添加节点的这一条线。若是使用last->next=p这一句代码，则last指针在之前前面的代码就已指向新的元素，因此需要创建一个新的临时指针Node *Old_last = last;来保存之前的最后一个节点。

Node<E> *Old_last = last;
last = new Node<E>(Old_last, element, NULL);
Old_last->next = last;

ps：也可以通过新的last->prev来获取原先的尾节点

        但是讨论到这里的代码的健壮性仍是不够完善，因为用到了next指针而未考虑到next指针为NULL的可能性 ，即当是一个空链表（一个元素都未添加的情况时）
添加为第一个元素时
        因此仍旧需要再增加一个当添加元素为第一个元素的讨论
        因为是添加的第一个元素，所以应该将first和last都指向这个新元素，而在前面的代码已经实现其余的连接，即在last = new Node(Old_last, element, NULL);代码中代表的就是last = new Node(NULL, element, NULL);，因此只需要添加一句first=last即可
只有一个元素

Node<E> *Old_last = last;
		last = new Node<E>(Old_last, element, NULL);
		if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
		}
		else
		{
			Old_last->next = last;
		}
4、总代码
template<class E>
void DouLinkList<E>::add(int index, E element)		//在某节点添加元素
{
	if (index == size)		//在尾节点添加元素
	{
		Node<E> *Old_last = last;
		last = new Node<E>(Old_last, element, NULL);
		if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
		}
		else
		{
			Old_last->next = last;
		}
	}
	else
	{
		Node<E>* next = find_node(index);
		Node<E>* prev = next->prev;
		Node<E>* p = new Node<E>(prev, element, next);
		next->prev = p;
		if (prev == NULL)		//如果index==0
		{
			first = p;
		}
		else
		{
			prev->next = p;
		}
	}

	size++;
}

①删除元素remove(int index)

1、中间节点

删除中间元素
        假设删除的是位置2的节点。与单链表的删除方法相似，只需要用一个节点保存被删除节点的元素来返回，然后找到要删除节点的前一个节点，将前一个节点的next指针指向下下一个节点，多了一点的是需要将所删除节点的prev指针指向删除节点的前一个节点，最后再把所删除的节点delete就可以了。
删除中间节点

2、 头、尾节点

对于头与尾删除的特殊情况就在于头节点的prev指针指向为空和尾节点的next指针为空
头、尾删除
        对于头节点是将first指针指向删除节点0的下一个节点1，再将节点1的prev指针指向NULL，而后一句的代码利用中间节点删除的代码就可完成。
        而尾节点的删除与头节点的删除几乎无区别，就不多赘述了。

3、总代码
template<class E>
E  LinkList<E>::remove(int index)		//移除某个元素，返回被移除的元素  要讨论是否为头节点
{

	Node<E>* p;		//创建一个节点，用来返回被移除的元素

	if (index == 0)		//若为头节点直接指向下个节点
	{
		p = first;
		first = first->next;
		size--;
	}
	else		//若不是头节点，让上一个节点指向这个节点的下一个节点
	{
		Node<E>* prev = find_node(index - 1);		//获得前一个节点
		p = prev->next;		//获得index节点
		prev->next = prev->next->next;		//前一个节点指向index后面这个节点
		size--;
	}

	E x = p->element;
	delete p;
	return x;
}

⚪总代码

Dou_Link_List.h

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


template<class E>
class Node
{
public:
	E element;
	Node<E>* next;
	Node<E>* prev;
	Node(Node<E>* prev,E element, Node<E>* next)
	{
		this->element = element;
		this->next = next;
		this->prev = prev;
	}
	~Node() {}
};

template<class E>
class DouLinkList
{
private:
	int size;
	Node<E>* first=NULL;
	Node<E>* last=NULL;

	static const int ELEMENT_NOT_FOUND = -1;

	Node<E>* find_node(int index);
public:
	void clear();		//清除所有元素
	void add(E element);		//在末尾添加元素
	void add(int index, E element);		//在index处添加元素
	int Size();		//求size
	int indexOf(E element);		//求某元素的位置
	bool isEmpty();		//链表是否为空
	bool contains(E element);		//某元素是否存在
	E get(int index);		//获得某节点的元素
	E set(int index, E element);		//设置某节点的元素
	E remove(int index);		//删除某节点的元素
	void print();		//打印

	~DouLinkList() {}
};

Dou_Link_List.cpp

#include"Dou_LinkList.h"

template<class E>
void DouLinkList<E>::clear()		//清除所有元素
{
	Node* q;
	Node<E>* p = first->next; 
	while (p != NULL)
	{
		q = p;
		p = p->next;
		delete q;
	}
	p = NULL;
	q = NULL;
}

template<class E>
int DouLinkList<E>::Size()		//求出链表的大小
{
	return size;
}

template<class E>
bool DouLinkList<E>::isEmpty()		//链表是否为空
{
	return size == 0;
}

template<class E>
bool DouLinkList<E>::contains(E element)		//某元素是否存在
{
	return indexOf(element) != -ELEMENT_NOT_FOUND;
}

template<class E>
void DouLinkList<E>::add(E element)		//在尾节点添加元素
{
	add(size, element);
}

template<class E>		//获得某元素的位置
int DouLinkList<E>::indexOf(E element)
{
	if (element == NULL)
	{
		Node<E>* node = first;
		for (int i = 0; i < size; i++)
		{
			if (node->element == NULL)
			{
				return i;
			}
			node = node->next;
		}
	}
	else
	{
		Node<E>* node = first;
		for (int i = 0; i < size; i++)
		{
			if (node->element==element)
			{
				return i;
			}
			node = node->next;
		}
	}
	return ELEMENT_NOT_FOUND;
}

template<class E>
E DouLinkList<E>::get(int index)		//获得某节点的元素
{
	return find_node(index).element;
}

template<class E>
E DouLinkList<E>::set(int index, E element)		//更改设置某节点元素
{
	Node<E>* node = find_node(index);
	E old = node->element;
	node->element = element;
	return old;
}

template<class E>
void DouLinkList<E>::add(int index, E element)		//在某节点添加元素
{
	if (index == size)		//在尾节点添加元素
	{
		Node<E> *Old_last = last;
		last = new Node<E>(Old_last, element, NULL);
		if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
		}
		else
		{
			Old_last->next = last;
		}
	}
	else
	{
		Node<E>* next = find_node(index);
		Node<E>* prev = next->prev;
		Node<E>* p = new Node<E>(prev, element, next);
		if (prev == NULL)		//如果index==0
		{
			first = p;
		}
		else
		{
			prev->next = p;
		}
		next->prev = p;
	}

	size++;
}

template<class E>
E DouLinkList<E>::remove(int index)			//删除某节点的元素
{
	Node<E>* p = find_node(index);
	Node<E>* prev = p->prev;
	Node<E>* next = p->next;
	if (prev == NULL)		//index==0
	{
		first = next;
	}
	else
	{
		prev->next = next;
	}
	if (next == NULL)		//index==size-1
	{
		last = prev;
	}
	else
	{
		next->prev = prev;
	}
	E x = p->element;
	delete p;
	return x;
}


template<class E>
void DouLinkList<E>::print()
{
	Node<E>* p = first;
	while (p!=NULL)
	{
		cout << p->element << "->" ;
		p = p->next;
	}
}

template<class E>
Node<E>* DouLinkList<E>::find_node(int index)
{
	if (index < 0 || index >= size)
	{
		throw "index不符合规范";
	}

	if (index < (size >> 1))
	{
		Node<E>* node = first;
		for (int i = 0; i < index; i++)
		{
			node = node->next;
		}
		return node;
	}
	else 
	{
		Node<E>* node = last;
		for (int i = size-1; i > index; i--)
		{
			node = node->prev;
		}
		return node;
	}
}

main.cpp

#include <iostream>
#include "Dou_LinkList.h"
#include "Dou_LinkList.cpp"

int main()
{
    DouLinkList<int> d_list;
    d_list.add(10);
    d_list.add(20);
    d_list.add(30);
    d_list.add(40);
    d_list.add(50);
    d_list.add(60);
    d_list.add(70);
    d_list.print();
    cout << endl;
    cout << d_list.remove(2) << endl;
    cout << d_list.set(3,10) << endl;
    cout << d_list.indexOf(60) << endl;
    d_list.print();
    return 0;
}

⚪对比

动态数组和双向链表的对比和使用
对比
附：
1.本博客是由学习小码哥视频所总结文章
2.代码都通过合格检测，请放心食用~

GXM.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
双向链表的C++实现
11-01
基础数据结构双向链表的C++描述版。实现了双向链表的基本功能。包括拷贝构造函数和IO操作符重载、赋值操作符重载
使用C++实现双链表
qq_58240448的博客
07-01 3023
c++实现的双链表
C++数据结构补充（双向链表）
Lao_tan的博客
06-27 637
C++数据结构之循环链表
单向链表插入元素操作
xiaov_sen的博客
06-27 1350
如果链表里没有结点,那么就是空链表, 需要在头部添加元素,当然一个好的插入算法不需要这样子. 兼容性是所有的程序员必备技能.如何到达兼容性? 还记得单向链表的添加元素操作? 单向链表添加操作 web link 那里有一个link函数采用的是 兼容性,无论哪一个位置,甚至是 empty LinkList都可以进行插入 如何 做呢? 按照位置插入 : 最小值0 最大值是list.size 插入元素思路: 参数: list,pos,value 判断 pos|.........
双向链表及其应用——实现多项式的加法及乘法
10-23
定义了线性表的抽象类，以及双向链表类及其结点类，实现双向链表的基本功能，还进一步应用到一元多项式的储存、加法和乘法，里面包含了项目文件，测试文件以及报告文件（一元多项式实现的思路）。
用双向链表做数据结构，编写一个通信录管理系统。
07-08
2.用双向链表做数据结构，编写一个通信录管理系统。本系统应完成以下几方面的功能。 输入信息——enter（）； 显示信息——display（）； 查找以姓名作为关键字——search（）； 删除信息——delete（）； 存盘——...
双向链表——1
05-02
这是一个双向链表，非常的可以。主要有3个头文件，10多个实现文件，还有一个主函数文件，希望大家多多支持！
数据结构C++描述
03-15
数据结构C++描述 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 3 1.2.3 引用参数 3 1.2.4 常量引用参数 4 1.2.5 返回值 4 1.2.6 递归...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
双向链表内结点的插入(C++)
04-22
在双向链表内插入一个结点，注释非常详细！适合菜鸟。网上下载的，觉得不错，和大家分享。
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
09-04
主要介绍了c++双向链表操作示例，包括创建双向链、删除双向链表、双向链表中查找数据、插入数据等,需要的朋友可以参考下
数据结构-双向链表(c++)超全超详细
热门推荐
Abieai的博客
12-01 1万+
文章目录前言一、双向链表是什么？二、双向链表上的基本操作1.定义双向链表2.初始化双链表3.前插法创建双链表4.尾插法创建双链表5.双向链表的遍历输出6.双链表的指定位置插入7.双链表的按位取值8.双链表的任意位置删除9.双链表的销毁三、全部代码(主函数部分比较凌乱）总结 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入，删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 提示：以.
C++双向链表操作
weixin_45890771的博客
03-17 87
C++双向链表的操作
利用C++实现双向链表的基本操作
weixin_43165699的博客
07-25 4087
本文采用利用C++实现了对双向链表的基本操作。操作包括：双向链表的构建、链表指定位置的插入、链表指定位置的删除、链表长度的获取、链表指定位置元素的获得及指定元素位置的获得、整体链表的删除。
c++实现双向链表，类模板双向链表
hugang的博客
09-06 1万+
c++实现双向链表的思想和c很类似，不同的是c++是将实现的函数放在类中，这样就可以由类实例化出对象再调用类中的函数进行添加、删除、查找、插入元素等功能。类模板实现双向链表在最后进行说明和实现，方法依然类似。 c++实现双向链表 #include #include using namespace std; typedef int Datatype; typedef
C++ 入门算法，新手必看之：双向“链表”（三）
cpp_learner的博客
03-24 468
俗话说得好，不懂链表的程序员，不配称为C/C++程序员。 继单向链表和循环链表之后，今天给大家分享链表的最后一片文章，双向链表。 如果不懂单向链表点下面这条链接，前去学习，学习！ https://blog.csdn.net/cpp_learner/article/details/105015219 如果不懂循环链表点下面这条链接，前去学习，学习！ https://blog.csdn.net/cpp...
线性表之双向链表的建立、查找、插入和删除（附C++程序）
ch18328071580的博客
07-07 3398
本文详细介绍了数据结构的双链表的定义，以及双向链表的建立、查找、插入和删除
c++ 双向链表
qq_42972267的博客
01-20 1032
#include &amp;lt;iostream&amp;gt; using std::cout; using std::endl; struct Node { int data; struct Node * next; struct Node * pre; }; 一、创建双向链表 Node * createList() { Node * head = new Node; if (NULL == ...
数据结构课程设计c++双向链表
最新发布
03-30
数据结构课程设计中，C++双向链表是一个常见的数据结构之一。它是一种线性数据结构，由多个节点组成，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。双向链表相比于单向链表，可以实现双向遍历。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GXM.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值