数据结构之双链表——c++模板元编程

最新推荐文章于 2024-05-15 08:56:34 发布
最新推荐文章于 2024-05-15 08:56:34 发布
阅读量299 收藏
点赞数
分类专栏： 数据结构 文章标签： c++ 双链表
原文链接：http://www.cnblogs.com/skywang12345/p/3561803.html
版权

想想自己好像并没有真正实现过数据结构里面的各类结构和算法，便打算动手用c++实现数据结构。这一篇是实现双链表，双链表较之于单链表，前者可以双向连接，既可以向前，也可以向后；而单链表的方向是单一的、固定的。好的，话不多说，直接上干货吧。

 首先，声明双链表节点 DNode，每个节点都有一个字段表示当前节点的值、有一个前驱字段来指向上一个节点、有一个后继字段指向下一个节点。默认构造和拷贝构造的区别是，如果初始化 DNode 时，如果没有指定value、prev、next 的话就使用默认构造函数 DNode()；如果初始化时指定了 value 、prev、next 的值，就会使用拷贝构造函数DNode(T t, DNode * prev, DNode * next)。

//声明双链表节点的模板类结构体
template<class T>
struct DNode
{
public:
	T value;
	DNode * prev;
	DNode * next;
public:
	//默认构造函数
	DNode(){}
	//拷贝构造函数
	DNode(T t, DNode * prev, DNode * next){
		this->value = t;
		this->prev = prev;
		this->next = next;
	}
};

 template<class T>是 C++ 模板编程的标识，T表示数据类型，进行实例化时可以自己定义为int,float,char等数据类型，也可以是结构体等自定义数据类型。

模板编程，顾名思义，是一个模板，可以给多个类或结构体套用的模板。我们在使用函数或类或结构体是时，都必须知名数据类型是什么，比如void print(int a,int b)这个函数只能传入int数据类型的参数；而void print(T a,T b)可以是任意类型。

定义好双链表节点结构后，继续定义双链表结构

//声明双链表的模板类
template<class T>
class DoubleLink{
public:
	DoubleLink();
	~DoubleLink();
	int size();	
	int is_empty();

	T get(int index);
	T get_first();
	T get_last();

	int insert(int index, T t);
	int insert_first(T t);
	int append_last(T t);

	int del(int index);
	int delete_first();
	int delete_last();

private:
	int count;
	DNode<T> * phead;
	DNode<T> * get_node(int index);
};

双链表时由每一个一开始定义的 DNode 节点连接起来的，count 表示双链表中 DNode 节点的数量，phead表示表头结点，get_node(int index)函数用来获取 index 位置的节点，返回的是 DNode * 类型。

 

  • DoubleLink()：构造函数，对DoubleLink()的定义如下：
template<class T>
DoubleLink<T>::DoubleLink():count(0){	
	//创建表头
	phead = new DNode<T>();
	phead->prev = phead->next = phead;
}

DoubleLink<T>::DOubleLink():count(0)：使用了Lambda表达式来初始化 count，赋值为0。

调用拷贝构造函数，即实例化对象时，会自动创建一个表头节点phead，phead的前驱和后继都是它本身。

 

  • ~DoubleLink()：析构函数，用来销毁对象
template<class T>
DoubleLink<T>::~DoubleLink(){
	//删除所有节点
	DNode<T> * ptmp;
	DNode<T> * pnode = phead->next;
	while (pnode != phead){
		ptmp = pnode;
		pnode = pnode->next;
		delete ptmp;
	}
	delete phead;
	phead = NULL;
}

析构函数的定义与构造函数相反，用来销毁对象，销毁每一个节点。

 

  • int size()：获取双链表中节点的数量
//获取双链表节点数
template<class T>
int DoubleLink<T>::size(){
	return count;
}
  • int is_empty()：判断是否为空函数
//判断双链表是否为空
template<class T>
int DoubleLink<T>::is_empty(){
	return count == 0;
}

如果count不为0,则返回0，否则返回1。

 

  • T get_node(int index)：获取 index 位置的节点，返回的是节点类型
//获取index位置的节点
template<class T>
DNode<T>* DoubleLink<T>::get_node(int index){
	if (index < 0 || index >= count){
		std::cout << "get node failed! the index in out of bound!" << std::endl;
		return NULL;
	}
	//正向查找
	if (index <= count / 2){
		int i = 0;
		DNode<T> * pindex = phead->next;
		for (i; i < index; i++){
			pindex = pindex->next;
		}
		return pindex;
	}
	//反向查找
	DNode<T> *rpindex = phead->prev;
	for (int j = 0; j < count - index - 1; j++){
		rpindex = rpindex->prev;
	}
	return rpindex;
}

首先判断 index 是否为有效位置，如果小于0或者超过双链表实际长度，输出错误信息。

若 Index 为有效位置，如果Index在链表的前半部分也就是在链表中间节点位置之前，就从链表头部开始遍历，一直到index位置；

如果index 在链表后半部分，也就是在链表中间节点位置之后，就从链表尾部反向遍历，一直到index位置。

之所以要先判断index在中间节点位置之前还时之后，主要是为能够减少遍历节点的数量，减少开支。

 

T get(int index)：获取index位置节点的值：

//获取index位置的节点的值
template<class T>
T DoubleLink<T>::get(int index){
	return get_node(index)->value;
}

 

T get_first()：获取链表第一个结点的值（不是头节点）。

//获取第一个节点的值
template<class T>
T DoubleLink<T>::get_first(){
	return get_node(0)->value;
}

 

T get_last()：获取链表最后一个节点的值。直接调用get_node(int index)函数获取最后一个节点的值

//获取最后一个节点的值
template<class T>
T DoubleLink<T>::get_last(){
	return get_node(count - 1)->value;
}

 

int insert(int index,T t)：将 t 插入到链表index的位置上。

//将节点插入到第index位置之前
template<class T>
int DoubleLink<T>::insert(int index, T t){
	if (index == 0){
		return insert_first(t);
	}
	DNode<T>*pindex = get_node(index);
	DNode<T>*pnode = new DNode<T>{ t, pindex->prev, pindex };

	pindex->prev->next = pnode;
	pindex->prev = pnode;
	count++;
	return 0;
}

 

int insert_first(T t)：将 t 插入到链表的一个节点位置。

//将节点插入到第一个节点处
template<class T>
int DoubleLink<T>::insert_first(T t){	
	DNode<T> *pnode = new DNode<T>{ t, phead, phead->next };
	phead->next->prev = pnode;
	phead->next = pnode;
	count++;
	return 0;
}

 

int append_last(T t)：将 t 加到链表尾部。注意链表连接的变化。

//将节点插入到最后一个节点处
template<class T>
int DoubleLink<T>::append_last(T t){
	DNode<T>*pnode = new DNode<T>{ t, phead->prev, phead };
	phead->prev->next = pnode;
	phead->prev = pnode;
	count++;
	return 0;
}

int del(int index)：删除 index位置的节点：

//删除index位置的节点
template<class T>
int DoubleLink<T>::del(int index){
	DNode<T> * pindex = get_node(index);
	pindex->next->prev = pindex->prev;
	pindex->prev->next = pindex->next;
	delete pindex;
	count--;
	return 0;
}

每次插入或者删除链表节点，count 都要加1或者减1.

 

int delete_first()：删除第一个节点。

//删除第一个节点
template<class T>
int DoubleLink<T>::delete_first(){
	return del(0);
}

 

int delete_last()：删除最后一个节点。

//删除最后一个节点
template<class T>
int DoubleLink<T>::delete_last(){
	return del(count - 1);
}

 

链表的声明和定义要在同一个文件里，声明和定义分文件的话，会报错的，因为模板编程不支持这样，具体可以参考

为什么C++编译器不能支持对模板的分离式编译。

 

 

下面是头文件的全部代码：

// DoubleLink.h

#include <iostream>

//声明双链表节点的模板类结构体
template<class T>
struct DNode
{
public:
	T value;
	DNode * prev;
	DNode * next;
public:
	//默认构造函数
	DNode(){}
	//拷贝构造函数
	DNode(T t, DNode * prev, DNode * next){
		this->value = t;
		this->prev = prev;
		this->next = next;
	}
};

//声明双链表的模板类
template<class T>
class DoubleLink{
public:
	DoubleLink();
	~DoubleLink();
	int size();	
	int is_empty();

	T get(int index);
	T get_first();
	T get_last();

	int insert(int index, T t);
	int insert_first(T t);
	int append_last(T t);

	int del(int index);
	int delete_first();
	int delete_last();

private:
	int count;
	DNode<T> * phead;
	DNode<T> * get_node(int index);
};


//定义双链表的模板类
template<class T>
DoubleLink<T>::DoubleLink():count(0){	
	//创建表头
	phead = new DNode<T>();
	phead->prev = phead->next = phead;
}
template<class T>
DoubleLink<T>::~DoubleLink(){
	//删除所有节点
	DNode<T> * ptmp;
	DNode<T> * pnode = phead->next;
	while (pnode != phead){
		ptmp = pnode;
		pnode = pnode->next;
		delete ptmp;
	}
	delete phead;
	phead = NULL;
}
 //获取双链表节点数
template<class T>
int DoubleLink<T>::size(){
	return count;
}

//判断双链表是否为空
template<class T>
int DoubleLink<T>::is_empty(){
	return count == 0;
}

//获取index位置的节点
template<class T>
DNode<T>* DoubleLink<T>::get_node(int index){
	if (index < 0 || index >= count){
		std::cout << "get node failed! the index in out of bound!" << std::endl;
		return NULL;
	}
	//正向查找
	if (index <= count / 2){
		int i = 0;
		DNode<T> * pindex = phead->next;
		for (i; i < index; i++){
			pindex = pindex->next;
		}
		return pindex;
	}
	//反向查找
	DNode<T> *rpindex = phead->prev;
	for (int j = 0; j < count - index - 1; j++){
		rpindex = rpindex->prev;
	}
	return rpindex;
}

//获取index位置的节点的值
template<class T>
T DoubleLink<T>::get(int index){
	return get_node(index)->value;
}

//获取第一个节点的值
template<class T>
T DoubleLink<T>::get_first(){
	return get_node(0)->value;
}

//获取最后一个节点的值
template<class T>
T DoubleLink<T>::get_last(){
	return get_node(count - 1)->value;
}

//将节点插入到第index位置之前
template<class T>
int DoubleLink<T>::insert(int index, T t){
	if (index == 0){
		return insert_first(t);
	}
	DNode<T>*pindex = get_node(index);
	DNode<T>*pnode = new DNode<T>{ t, pindex->prev, pindex };

	pindex->prev->next = pnode;
	pindex->prev = pnode;
	count++;
	return 0;
}

//将节点插入到第一个节点处
template<class T>
int DoubleLink<T>::insert_first(T t){	
	DNode<T> *pnode = new DNode<T>{ t, phead, phead->next };
	phead->next->prev = pnode;
	phead->next = pnode;
	count++;
	return 0;
}

//将节点插入到最后一个节点处
template<class T>
int DoubleLink<T>::append_last(T t){
	DNode<T>*pnode = new DNode<T>{ t, phead->prev, phead };
	phead->prev->next = pnode;
	phead->prev = pnode;
	count++;
	return 0;
}


//删除index位置的节点
template<class T>
int DoubleLink<T>::del(int index){
	DNode<T> * pindex = get_node(index);
	pindex->next->prev = pindex->prev;
	pindex->prev->next = pindex->next;
	delete pindex;
	count--;
	return 0;
}

//删除第一个节点
template<class T>
int DoubleLink<T>::delete_first(){
	return del(0);
}

//删除最后一个节点
template<class T>
int DoubleLink<T>::delete_last(){
	return del(count - 1);
}

 

下面做个测试：

#include "DoubleLink.h"
#include <string>
void int_test(){
	DoubleLink<int> *pdlink = new DoubleLink<int>();
	pdlink->insert_first(20);
	pdlink->append_last(10);
	pdlink->insert(1, 90);

	std::cout << "双链表第一个节点为:" << pdlink->get_first() << std::endl;
	std::cout << "双链表最后一个节点为:" << pdlink->get_last() << std::endl;
	
	pdlink->delete_first();
	pdlink->delete_last();
	pdlink->del(0);
	if (pdlink->is_empty()){
		std::cout << "DoubleLink is empty" << std::endl;
	}
	else{
		std::cout << "DoubleLink is not empty" << std::endl;
	}
	for (int i = 0; i < pdlink->size(); i++){
		std::cout << pdlink->get(i) << std::endl;
	}
}


void string_test(){
	DoubleLink<std::string> *pslink = new DoubleLink<std::string>();
	//pslink->append_last("Hello world! key!");
	pslink->insert_first("Hello world! key!");
	pslink->insert(0, "My name is zky");
	pslink->append_last("呵呵");
	for (int i = 0; i < pslink->size(); i++){
		std::cout << pslink->get(i) << std::endl;
	}
}


void object_test(){
	struct stu{
		int id;
		char name[20];
	};

	static struct stu arr_stu[] = {
		{0,"小强"},
		{ 1, "小李" },
		{2,"小刚"}
	};

	DoubleLink<stu> *polink = new DoubleLink<stu>();
	polink->insert(0, arr_stu[0]);
	polink->insert_first(arr_stu[2]);

	for (int i = 0; i < polink->size(); i++){
		std::cout << polink->get(i).id << "	" << polink->get(i).name << std::endl;
	}

}


int main(){
	//int_test();
	//string_test();
	object_test();
	std::cin.get();
	return 0;
}

好了，双链表的学习就到这了，后续会学习其他数据结构。

车小小的老头子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——C++中实现双链表（含完整代码）
huaimaisui的博客
07-10 2681
双链表相关代码。 1、创建双链表(-1结束) 2、遍历双链表 3、插入双链表元素 4、双链表删除元素 5、判断双链表是否为空 6、双链表的长度 7、查找双链表元素 0、退出程序 纯手打，亲测可以运行，使用自取。............
c++一种简单的链表写法
qq_34277776的博客
03-22 460
简单的C++链表结构和代码
C++双向链表
King逍灬遥
11-30 695
C++双向链表 双向链表顾名思义就是每个结点具有两个指针，一个指向前一个结点，一个指向后一个结点，我们不必拘束与单链表的创建遍历操作等，这样大大减少了使用中存在的效率问题。 在单链表中，我们有一个数据域还有一个指针域，数据域用来存储相关数据，而指针域负责链表之间的“联系”，双向链表具有两个指针域，一个负责向后连接，一个负责向前连接。 //单链表结构 template<class ...
C++ 模板保姆级详解——template＜class T＞(什么是模板？模板分哪几类
最新发布
2401_84976219的博客
05-15 703
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！ 网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取
C++以类的形式实现链表
克格莫
03-21 455
#include<iostream> using namespace std; class node { private: public: char data; node* next; node(){ this->next = NULL; } // void setData(char c){this->d...
C++实现双链表（Double Linked List）
weixin_42133358的博客
05-14 1618
C++实现双链表（Double Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 双链表与单链表相同，都是由结点（Node）组成，但结点结构有所不同，结点中有一个数据域和两个指针域，数据域存放结点中的数据，一个指针域指向下一个结点的地址，另一个指针指向上一个结点的地
数据结构与算法分析C++语言描述第四版参考答案
10-13
3. C++编程：此书使用C++语言作为实现数据结构和算法的工具，涵盖了C++的基础知识，如类、对象、模板、STL（标准模板库）、智能指针、异常处理等。通过源代码，读者可以学习如何利用C++的特性来实现高效的数据结构和...
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
网上搜集的七种双向链表模板c++实现
12-15
在编程领域，双向链表是一种重要的数据结构，它在C++中被广泛使用。与单向链表不同，双向链表允许元素在正向和反向两个方向上进行遍历，这为程序员提供了更大的灵活性。这里我们将深入探讨网上搜集的七种双向链表...
数据结构C++语言描述——应用标准模板库（STL）
12-06
在C++编程语言中，数据结构的实现常常借助于标准模板库（Standard Template Library，简称STL）。STL是C++库的一部分，提供了各种容器、迭代器、算法和函数对象，极大地简化了复杂数据结构的编程。 STL中的容器是...
图解数据结构C++版源码
01-13
C++中，`std::stack`是标准模板库提供的栈实现，可以通过容器如`std::vector`或`std::deque`作为底层数据结构。 3. **队列**：队列是一种先进先出（FIFO）的数据结构，适用于处理任务调度、缓冲区管理等问题。C++中...
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
weixin_33713707的博客
02-01 405
0. 数据结构图文解析系列 数据结构系列文章 数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现 数据结构图文解析之：栈的简介及C++模板实现 数据结构图文解析之：队列详解与C++模板实现 数据结构图文解析之：树的简介及二叉排序树C++模板实现. 数据结构图文解析之：AVL树详解及C++模板实现 数据结构图文解析之：二叉堆详解及C++模板实现 1....
2023年node.js最新版(18.15.0)详细安装教程(保姆级)
热门推荐
全栈技术分享，项目分享，资料分享
03-23 3万+
如上图所示，npm 全局模块存放位置以及cache的存放位置，默认是在 C 盘 “C:\Users\用户\AppData” 下。可以看到当前的版本 LTS是大多用户使用的稳定版本, Current是最新版本, 这里选择的是稳定版本(18.15.0)设置全局模块的安装路径到 “node_global” 文件夹 npm config set prefix 命令。2.在 nodejs 安装目录下，创建 “node_global” 和 “node_cache” 两个文件夹。查看npm全局模块的存放路径。
NodeJS入门（一）---nodejs详细安装步骤
tengtianshan的专栏
04-01 2万+
npm使用手册https://www.npmjs.cn/getting-started/installing-npm-packages-locally/ node.js使用https://www.runoob.com/nodejs/nodejs-npm.html 初学NodeJS，就是要弄清楚什么是nodejs，能做什么，怎么用。。 什么是nodejs? 脚本语言需要一个解析器才能运行，JavaScript是脚本语言，在不同的位置有不一样的解析器，如写入html的js语言，浏览器是它的...
数据结构--带头结点的双向链表
啦~啦~啦~的博客
04-22 8747
带头结点的双向链表    之前用c语言写了单链表，单链表是每个结点结构体中包含一个指针，指向下一个结点，还有一个数据类型，用于存储当前结点的值。单链表的结构简单，所以会导致在有时候，它有一些弊端，比如需要访问使用某一个结点的前一个结点的时候，就需要重新遍历一次链表来查找这个结点。所以在大多数情况下我们都选择使用双向链表。 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，...
双向链表基本操作的实现（带头节点）
weixin_42168411的博客
09-06 395
双向链表的基本操作实现（含头节点） typedef struct DNode {//定义双链表的节点类型 int data;//数据域 struct DNode* prior, * next;//前驱和后继指针 }DNode,*DLinkList; 以下几种操作 bool InitDLinkList(DLinkList& L) {//初始化双链表 bool Empty(DLinkList L) {//判断双链表是否为空 bool InsertNextDNode(DNode* p, DNode*
模板双向链表
ChaseRaod的博客
04-29 1143
顺序表和链表几乎是面试必考点，前面我们已经介绍过了模板顺序表(http://blog.csdn.net/ChaseRaod/article/details/70477564)这篇文章给大家介绍介绍一下模板双向链表用模板写链表主要还是为了实现代码的类型通用性，以下代码将实现链表的增、删、查、改、判空等操作。#define _CRT_SECURE_NO_WARNINGS 1 #pragma once #
数据结构之C语言实现双向链表（学习笔记）
weixin_45803046的博客
07-16 317
一、双向链表定义 双向链表（double linked list）是在单链表的每个结点中，再设置一个指向其前驱结点的指针域 二、空表的判断条件 //head的是头结点 p->next = head; //或者 p->prior = head; 三、双向链表的基本操作 typedef int ElemType; typedef struct DNode { ElemType data; struct DNode* next; //直接后继指针 struct DNode* prior;
1.4双向链表表示与实现
小王同学的博客
12-13 204
1.4双向链表 1、双向链表是指链表中每个结点都有两个指针域，一个指向后继结点，一个指向前驱结点。prior和next. 2、双向链表也分带头和不带头，带头操作更加方便。双向链表也有循环结构，称双向循环链表。 3、带头双向循环链表的判空条件为head->prior==head或head->next==head； 代码实现： DLinkList.h #pragma once #include <stdio.h> #include <stdlib.h> typ
C++第四版：数据结构与算法详解——从基础到应用
《数据结构与算法在C++第四版》提供了一个全面的学习平台，帮助读者掌握C++编程中的核心概念，并通过实际项目演示如何在实践中运用这些理论。无论你是初学者还是经验丰富的开发者，这本书都能为你在数据结构和算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值