数据结构复习（五）模板类封装带头结点的双向循环链表

最新推荐文章于 2024-07-25 15:58:50 发布
最新推荐文章于 2024-07-25 15:58:50 发布
阅读量78 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66151870/article/details/129011534
版权

链表结点结构体：

template<class T>
struct ListNode
{
	T data;       // 数据域
	ListNode* next;  // 指针域
	ListNode* prev;  // 指针域
	ListNode(const T& val = T())
	{
		data = val;
		next = nullptr;
		prev = nullptr;
	}
	~ListNode()
	{
		next = nullptr;
		prev = nullptr;
	}
};

 链表结构体（对于链表销毁选择尾部断开置空方式）

template<class T>
class List
{
	typedef ListNode<T> Node;    
            // 使用别名真的好用，上一篇queue全篇结点定义都是Node<T>
public:
	List()
	{
		GetListHead();    // 头结点
	}
	~List()
	{
		head->prev->next = nullptr;    // 断开尾部链表使其指向空
		Node* del = head;    
		while (head)
		{
			head = head->next;
			delete del;
			del = head;
		}
	}
private:
	Node* head;
	void GetListHead()    // 创建头结点
	{
		head = new Node();
		head->next = head;
		head->prev = head;
	}
};

源码

#pragma once
#include<iostream>


template<class T>
struct ListNode
{
	T data;
	ListNode* next;
	ListNode* prev;
	ListNode(const T& val = T())
	{
		data = val;
		next = nullptr;
		prev = nullptr;
	}
	~ListNode()
	{
		next = nullptr;
		prev = nullptr;
	}
};
template<class T>
class List
{
	typedef ListNode<T> Node;
public:
	List()
	{
		GetListHead();
	}
	~List()
	{
		head->prev->next = nullptr;
		Node* del = head;
		while (head)
		{
			head = head->next;
			delete del;
			del = head;
		}
	}
	void PushBack(const T& val = T())
	{
		Node* newNode = new Node(val);
		Node* cur = head;
		while (cur->next != head)
			cur = cur->next;
		cur->next = newNode;
		head->prev = newNode;
		newNode->next = head;
		newNode->prev = cur;
		cur = nullptr;
	}
	void PushFront(const T& val = T())
	{
		Node* Head_Next = head->next;
		Node* newNode = new Node(val);
		head->next = newNode;
		newNode->prev = head;
		newNode->next = Head_Next;
		Head_Next->prev = newNode;
		Head_Next = nullptr;
	}
	void PopBack()
	{
		if (head->next == head)
			return;
		Node* del = head->prev;
		Node* pre = del->prev;
		pre->next = head;
		head->prev = pre;
		delete del;
		del = nullptr;
		pre = nullptr;
	}
	void PopFront()
	{
		Node* del = head->next;
		if (head->next == head)
		{
			del = nullptr;
			return;
		}
		else if (head->next->next == head)
		{
			delete del;
			head->next = head;
			head->prev = head;
		}
		else
		{
			Node* cur = head->next->next;
			head->next = cur;
			cur->prev = head;
			delete del;
		}
		del = nullptr;
	}
	Node* InsertPos(Node* pos, const T& val = T())
	{
		Node* pre = pos->prev;
		Node* newNode = new Node(val);
		pre->next = newNode;
		newNode->next = pos;
		newNode->prev = pre;
		pos->prev = newNode;
		pre = nullptr;
		return newNode;
	}
	void ErasePos(Node* pos)
	{
		if (pos == head)
			return;
		Node* cur = pos->prev;
		cur->next = pos->next;
		cur->next->prev = cur;
		delete pos;
		pos = nullptr;
	}
	void Print()
	{
		Node* cur = head->next;
		std::cout << "Head->";
		if (cur == head)
		{
			std::cout << "该链表仅有一个头结点" << std::endl;
			return;
		}
		while (cur != head)
		{
			std::cout << cur->data << "->";
			cur = cur->next;
		}
		std::cout <<"nullptr" << std::endl;
	}
	Node* Get()
	{
		return head;
	}
private:
	Node* head;
	void GetListHead()
	{
		head = new Node();
		head->next = head;
		head->prev = head;
	}
};

void Test()
{
	List<int> l;
	l.PushBack(1);
	l.PushBack(2);
	l.PushBack(3);
	l.PushBack(4);
	l.PushBack(5);
	l.PushBack(6);
	ListNode<int>* cur = l.Get()->next;
	for (int i = 0; i < 3; i++)
	{
		cur = cur->next;
	}
	cur = l.InsertPos(cur, 10);
	cur = cur->next;
	l.ErasePos(cur);
	l.Print();
	return;
}

void Test2()
{
	List<int> l;
	l.PushFront(1);
	l.PushFront(2);
	l.PushFront(3);
	l.PushFront(4);
	l.PushFront(5);
	l.Print();

	l.PopFront();
	l.PopFront();
	l.PopFront();
	l.Print();
	l.PopFront();
	l.PopFront();
	l.Print();
	l.PopFront();
	l.Print();
	return;
}

void Test1()
{
	List<int> l;
	l.PushBack(1);
	l.PushBack(2);
	l.PushBack(3);
	l.PushBack(4);
	l.PushBack(5);
	l.Print();

	l.PopBack();
	l.PopBack();
	l.PopBack();
	l.Print();
	l.PopBack();
	l.PopBack();
	l.Print();
	l.PopBack();
	l.Print();
	return;
}

#pragma once
#include<iostream>


template<class T>
struct ListNode
{
    T data;
    ListNode* next;
    ListNode* prev;
    ListNode(const T& val = T())
    {
        data = val;
        next = nullptr;
        prev = nullptr;
    }
    ~ListNode()
    {
        next = nullptr;
        prev = nullptr;
    }
};
template<class T>
class List
{
    typedef ListNode<T> Node;
public:
    List()
    {
        GetListHead();
    }
    ~List()
    {
        head->prev->next = nullptr;
        Node* del = head;
        while (head)
        {
            head = head->next;
            delete del;
            del = head;
        }
    }
    void PushBack(const T& val = T())
    {
        Node* newNode = new Node(val);
        Node* cur = head;
        while (cur->next != head)
            cur = cur->next;
        cur->next = newNode;
        head->prev = newNode;
        newNode->next = head;
        newNode->prev = cur;
        cur = nullptr;
    }
    void PushFront(const T& val = T())
    {
        Node* Head_Next = head->next;
        Node* newNode = new Node(val);
        head->next = newNode;
        newNode->prev = head;
        newNode->next = Head_Next;
        Head_Next->prev = newNode;
        Head_Next = nullptr;
    }
    void PopBack()
    {
        if (head->next == head)
            return;
        Node* del = head->prev;
        Node* pre = del->prev;
        pre->next = head;
        head->prev = pre;
        delete del;
        del = nullptr;
        pre = nullptr;
    }
    void PopFront()
    {
        Node* del = head->next;
        if (head->next == head)
        {
            del = nullptr;
            return;
        }
        else if (head->next->next == head)
        {
            delete del;
            head->next = head;
            head->prev = head;
        }
        else
        {
            Node* cur = head->next->next;
            head->next = cur;
            cur->prev = head;
            delete del;
        }
        del = nullptr;
    }
    Node* InsertPos(Node* pos, const T& val = T())
    {
        Node* pre = pos->prev;
        Node* newNode = new Node(val);
        pre->next = newNode;
        newNode->next = pos;
        newNode->prev = pre;
        pos->prev = newNode;
        pre = nullptr;
        return newNode;
    }
    void ErasePos(Node* pos)
    {
        if (pos == head)
            return;
        Node* cur = pos->prev;
        cur->next = pos->next;
        cur->next->prev = cur;
        delete pos;
        pos = nullptr;
    }
    void Print()
    {
        Node* cur = head->next;
        std::cout << "Head->";
        if (cur == head)
        {
            std::cout << "该链表仅有一个头结点" << std::endl;
            return;
        }
        while (cur != head)
        {
            std::cout << cur->data << "->";
            cur = cur->next;
        }
        std::cout <<"nullptr" << std::endl;
    }
    Node* Get()
    {
        return head;
    }
private:
    Node* head;
    void GetListHead()
    {
        head = new Node();
        head->next = head;
        head->prev = head;
    }
};

void Test()
{
    List<int> l;
    l.PushBack(1);
    l.PushBack(2);
    l.PushBack(3);
    l.PushBack(4);
    l.PushBack(5);
    l.PushBack(6);
    ListNode<int>* cur = l.Get()->next;
    for (int i = 0; i < 3; i++)
    {
        cur = cur->next;
    }
    cur = l.InsertPos(cur, 10);
    cur = cur->next;
    l.ErasePos(cur);
    l.Print();
    return;
}

void Test2()
{
    List<int> l;
    l.PushFront(1);
    l.PushFront(2);
    l.PushFront(3);
    l.PushFront(4);
    l.PushFront(5);
    l.Print();

    l.PopFront();
    l.PopFront();
    l.PopFront();
    l.Print();
    l.PopFront();
    l.PopFront();
    l.Print();
    l.PopFront();
    l.Print();
    return;
}

void Test1()
{
    List<int> l;
    l.PushBack(1);
    l.PushBack(2);
    l.PushBack(3);
    l.PushBack(4);
    l.PushBack(5);
    l.Print();

    l.PopBack();
    l.PopBack();
    l.PopBack();
    l.Print();
    l.PopBack();
    l.PopBack();
    l.Print();
    l.PopBack();
    l.Print();
    return;
}

 

曾几何时`
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向循环链表的模板封装
freex64的专栏
03-09 176
程序员对双向循环链表的熟悉程度，那就像周星扮演的唐伯虎说《椿树秋香图》一样——“画了几百次啦，熟得很”！。所以直接进入正题模板封装，封装之后模板名称是rubbish::structlist。
用C++类实现 双向非循环带头结点的链表
身在边城 心在编程
06-24 273
双向非循环带头结点的链表 图好像有点丑~~ 下列是相关操作的代码（C++ 类封装） #pragma once #include <iostream> #include <stdlib.h> #include <assert.h> using namespace std; //对一个结点进行封装 class Node { public: Node* _nex...
用类模板封装链表
蜗牛也是牛
06-05 560
闲来无聊，用类的模板封装的链表，记录下来，说不定哪天用得上那。 template class List { public: //定义节点类型 typedef struct Node { VALUE_TYPE data;    //数据域 struct Node *next;  //指针域：直接后继的指针 // struct Node *prior; //指针域：直接前驱的指针
链表及相关功能封装——C++实现、类封装
ctz6d1p的博客
10-26 663
链表及相关功能封装——C++实现、类封装数据结构数据结构实验课作业链表的实现
封装链表：
weixin_72151098的博客
08-26 167
链表的最后一个结点的next不再指向NULL，而是指向头结点，这种链表称为单向循环链表，简称循环链表，它好处是可以通过任意结点来遍历整个链表。牺牲了随机访问的功能、也没达到链表动态申请内存的效果，只是给没有指针的编程语言实现链表的一种方式，适用范围不大。顺序结构：数据存储在连续的内存中，可以使用数据的相对位置来表示数据之间的关系。注意：栈、队列的功能受限、只能操作栈顶或队头队尾，除此之外操作其他任何元素都是非法的。创建、销毁、清空、添加、删除、查询、访问、修改、排序、遍历。栈2不空，栈1不能到栈2。...
c++封装模板单链表
ylh的博客
07-31 357
C++模板单链表的封装，适用于任意数据类型
数据结构初阶--双向循环链表（讲解+类模板实现）
sinat_40572875的博客
11-30 423
看下面的图，就是我今天要给大家分享有结构——带头双向循环链表。这里的头是不存放任何数据的，就是一个哨兵卫的头结点。
C++实现双向循环链表
BeiXi's Blog
02-07 1573
本次博文是关于利用C++模板的方式实现的双向循环链表以及双向循环链表的基本操作，在之前的博文C++语言实现双向链表中，已经给大家分析了双向循环链表的结构，并以图示的方式给大家解释了双向循环链表的基本操作。本篇文章利用C++实现了双向循环链表的基本操作，其中包括： 双向循环链表 实现的功能 头部插入结点建立链表 尾部插入结点建立链表 实现指定位置插入结点 查找给定数值是否存在 ...
用c语言双向循环链表,C语言实现双向循环链表
weixin_28487725的博客
05-21 1014
说明 相比Linux内核链表宿主结构可有多个链表结构的优点,本函数集侧重封装性和易用性,而灵活性和效率有所降低. 可基于该函数集方便地构造栈或队列集. 本函数集暂未考虑并发保护. 一 概念 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序通过链表中的指针链接次序实现.链表由一系列存储结点组成,结点可在运行时动态生成.每个结点均由两部分组成,即存储数据元素的数据...
数据结构与算法实验（C++）：单链表实验-代码
01-18
2）定义单链表类模板，例如LinkList，封装单链表的操作算法，包括 a.创建 b.释放 c.按值查找 d.按序号查找 e.第i个位置插入和删除元素 f.求链表长度 g.输出单链表所有元素 h.原地置逆单链表 i.判断单链表是否...
header-files-of-linear-table.rar_Table_c++链表类
09-23
在C++编程中，线性表是一种非常基础且重要的数据结构。它是由n（n≥0）个相同类型元素构成的有限序列，可以是顺序存储或链式存储。本资源"header-files-of-linear-table.rar"提供了线性表的C++实现，主要关注链表类...
数据结构(本科)期末综合练习二(填空与判断题).doc
07-06
35. 双向循环链表中，前驱结点地址可以通过rlink域找到。 36. 栈是后进先出（LIFO）表，队列是先进先出（FIFO）表。 37. 向链式栈插入新结点时，栈顶指针更新为新结点的地址，然后将新结点的指针域设置为原栈顶...
C++模板类——双链表
05-31
使用C++做的双链表模板类 具有头插法，尾插法，左向插入，右向插入，删除结点，获取结点值，设置结点值，复制构造函数，还重载了输出操作符、赋值操作符、相等操作符和不等操作符，还具有倒置链表的功能。还有结点类...
3.1、数据结构-线性表
yoyo勰的博客
07-25 727
顺序列表由于元素与元素之间是相邻的，我们可以直接从首元素来查到每个元素的位置。【2021年】设有栈S和队列Q初始状态为空,数据元素序列a,b,c,d,e,f依次通过栈S,且多个元素从S出栈后立即进入队列Q,若出队的序列是b,d,f,e,c,a,则S中的元素最多时,栈底到栈顶的元素依次为()。在时间方面，由顺序表和链表的存储方式可知，当需要对元素进行破坏性操作（插入、删除）时，链表效率更高，因为其只需要修改指针指向即可，而顺序表因为地址是连续的，当删除或插入一个元素后，后面的其他节点位置都需要变动。
【数据结构】栈的实现
t5y22的博客
07-25 487
struct。
2024.7.24 作业
qq_64434282的博客
07-24 2370
【代码】2024.7.24 作业。
操作系统期末考试试题和标准答案及评分标准.doc
08-01
操作系统期末考试试题和标准答案及评分标准
Java项目：基于SSM框架实现的疫情物资管理系统【ssm+B/S架构+源码+数据库+开题报告+答辩PPT+毕业论文】
最新发布
08-01
二、技术实现 jdk版本：1.8 及以上 ide工具：IDEA或者eclipse 数据库: mysql5.7 后端：spring+springmvc+mybatis+maven+mysql 前端：JSP，css，js 三、系统功能 系统登录角色包括管理员、采购员、后勤人员、财务人员 管理员管理物资申领，物资出入库，物资采购，财务报销。主要功能包括： 用户登录 用户注册 首页 个人中心 修改密码 个人信息 物资信息管理 物资分类管理 出库信息管理 入库信息管理 申领物资管理 部门管理 职务管理 物资采购管理 财务报销管理 采购员管理 后期人员管理 财务人员管理 采购员查询物资和财务报销，管理物资采购。主要功能包括： 个人中心 修改密码 个人信息 查询财务报销 物资采购管理 查询物资信息 后勤人员对物资进行出入库操作，统计物资出入库的数据，审核并统计物资申领信息。主要功能包括： 个人中心 修改密码 个人信息 查询物资采购 申领物资管理 入库信息管理 出库信息管理 物资信息管理 财务人员查询物资采购，审核财务报销信息。主要功能包括： 个人中心 修改密码 个人信息 财务报销管理等功能
带头结点循环链表详解：数据结构入门经典
本讲义主要探讨了带头结点循环单链表这一数据结构的概念及其在计算机科学中的应用。带头结点循环链表(L(a))是链表的一种特殊形式，它包含一个额外的头结点，使得链表形成一个循环，即最后一个节点的next指针指向第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值