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

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

单向循环列表

⚪概念

顾名思义，单向循环链表就是在单向链表的基础上实现了循环，即将最后一个节点再指向第一个节点。
单向循环列表

⚪难点

由于单向循环链表是对于单向链表的一个改进，因此只需要在单向链表代码的基础上进行部分改动。而单向循环链表和单向链表的区别就在于多了一根尾节点指向头节点的线，所以只有添加和删除操作的头尾部分的代码进行改进。

①添加

1、头

当添加头节点时，除了将添加节点的next指针指向原先节点之外要考虑到头尾之间的线，因此还要获得尾节点，再将尾节点的next指针指向新添加的头节点


	if (index == 0)
	{
		Node<E>* New_first = new Node<E>(element, first);		//单独拿出头节点，以防拿最后一个节点的时候拿到的是尾节点的前一个结点

		//拿到最后一个位置的节点
		Node<E>* last = find_node(size - 1);
		last->next = New_first;
		first = New_first;		//最后再拿这个新节点覆盖头节点
	}

第一个节点
而有一种特殊情况就是当添加的头节点是第一个节点那么在获得尾节点时获得的就是自己本身。
那么就要把Node<E>* last = find_node(size - 1);这句代码改成Node<E>* last = (size == 0) ? New_first : find_node(size - 1);
因此最后的代码是：

if (index == 0)
	{
		Node<E>* New_first = new Node<E>(element, first);		//单独拿出头节点，以防拿最后一个节点的时候拿到的是尾节点的前一个结点

		//拿到最后一个位置的节点
		Node<E>* last = (size == 0) ? New_first : find_node(size - 1);
		last->next = New_first;
		first = New_first;		//最后再拿这个新节点覆盖头节点
	}
2、尾

在处理头部的操作和尾部的操作无过多区别，没有头指针的改变，更为简单，便不过多赘述

Node<E>* prev = find_node(index - 1);		//获得前一个节点
		prev->next = new Node<E>(element, prev->next);		//由于从右向左运算 首先让新元素的下一个指向原有位置使其成为下一个元素 再让前节点指向新元素
3、总代码
template<class E>
void Cirle_LinkList<E>::add(int index, E element)		//在指定位置添加元素
{
	if (index == 0)
	{
		Node<E>* New_first = new Node<E>(element, first);		//单独拿出头节点，以防拿最后一个节点的时候拿到的是尾节点的前一个结点

		//拿到最后一个位置的节点
		Node<E>* last = (size == 0) ? New_first : find_node(size - 1);
		last->next = New_first;
		first = New_first;		//最后再拿这个新节点覆盖头节点
	}
	else
	{
		Node<E>* prev = find_node(index - 1);		//获得前一个节点
		prev->next = new Node<E>(element, prev->next);		//由于从右向左运算 首先让新元素的下一个指向原有位置使其成为下一个元素 再让前节点指向新元素
	}
	size++;
}

②删除

1、头

删除头节点在单向链表中将first指针指向头节点的下一个节点之外，还要将尾节点的next指针指向新的头节点，最后再delete原来的头节点即可。
删除头节点

p = first;
			Node<E>* last = find_node(size - 1);
			first = first->next;
			last->next = first;

而此处的删除也有一个特殊情况，因为上方代码存在size-1，当size=1，即本来只有一个元素，此处代码就无法通用了，因此还要增加一个size=1时的讨论。
只有一个元素
那么此处只要将first=NULL再delete这个元素即可

if (size == 1)
		{
			first = NULL;
		}
		else
		{
			p = first;
			Node<E>* last = find_node(size - 1);
			first = first->next;
			last->next = first;
		}
2、尾

在处理头部的操作和尾部的操作无过多区别，没有头指针的改变，更为简单，便不过多赘述

Node<E>* prev = find_node(index - 1);		//获得前一个节点
		p = prev->next;		//获得index节点
		prev->next = prev->next->next;		//前一个节点指向index后面这个节点
3、总代码
template<class E>
E Cirle_LinkList<E>::remove(int index)		//移除某个元素，返回被移除的元素  要讨论是否为头节点
{

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

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

⚪总代码

Cir_Single_List.h

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

template<class E>
class Node
{
public:
	E element;		//元素值

	Node<E>* next;		//指向下一个节点

	Node() {};		//不含参数的构造函数

	Node(E element, Node<E>* next)		//含参数的构造函数
	{
		this->element = element;
		this->next = next;
	}

	~Node() {};		//析构函数
};


template<class E>
class Cirle_LinkList
{

private:
	int size;		//数据大小
	Node<E>* first;		//头节点

	static const int ELEMENT_NOT_FOUND = -1;		//代表未找到此值

public:

	void clear();						//清除所有节点
	void add(E element);					//在尾节点添加元素
	void add(int index, E element);		//在指定位置添加元素	
	int cacul_size();					//计算size的大小
	int indexOf(E element);				//查找元素element是否存在（只需要第一个出现的元素）
	bool isEmpty();						//看链表是否为空
	bool contains(E element);	     	//是否包含某个元素
	E get(int index);					//获得某个index元素的值
	E set(int index, E element);			//在index位置设置元素，返回原来的element
	E remove(int index);					//移除某个元素，返回被移除的元素  要讨论是否为头节点
	void print();						//输出
	Node<E>* find_node(int index);		//找出某个节点

	~CIrle_LinkList() {};
};

Cir_Single_List.cpp

#include <iostream>
#include "Circle_Link_list.h"


template<class E>
void Cirle_LinkList<E>::clear()		//清除所有节点
{
	size = 0;
	Node<E>* p;
	while (this->first)
	{
		p = first->next;
		free(first);
		first = p;
	}
	cout << "已被清空" << endl;
}

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

template<class E>
void Cirle_LinkList<E>::add(int index, E element)		//在指定位置添加元素
{
	if (index == 0)
	{
		Node<E>* New_first = new Node<E>(element, first);		//单独拿出头节点，以防拿最后一个节点的时候拿到的是尾节点的前一个结点

		//拿到最后一个位置的节点
		Node<E>* last = (size == 0) ? New_first : find_node(size - 1);
		last->next = New_first;
		first = New_first;		//最后再拿这个新节点覆盖头节点
	}
	else
	{
		Node<E>* prev = find_node(index - 1);		//获得前一个节点
		prev->next = new Node<E>(element, prev->next);		//由于从右向左运算 首先让新元素的下一个指向原有位置使其成为下一个元素 再让前节点指向新元素
	}
	size++;
}

template<class E>
int Cirle_LinkList<E>::cacul_size() //计算size的大小
{
	return size;
}

template<class E>
int Cirle_LinkList<E>::indexOf(E element)		//查找元素element是否存在（只需要第一个出现的元素）
{
	if (element == NULL)		//考虑element为空的情况
	{
		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 (element == node->element)
			{
				return i;
			}
			node = node->next;
		}
	}
}

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

template<class E>
bool Cirle_LinkList<E>::contains(E element)
{
	return indexOf(element) != -ELEMENT_NOT_FOUND;
}

template<class E>
E Cirle_LinkList<E>::get(int index)		//获得某个index元素的值
{
	return find_node(index).element;		//可以直接利用find_node()函数
}

template<class E>
E Cirle_LinkList<E>::set(int index, E element)		//在index位置设置元素，返回原来的element
{
	Node<E>* node = find_node(index);
	E old = node->element;		//用来保存原来的element
	node->element = element;
	return old;
}

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

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

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

template<class E>
void Cirle_LinkList<E>::print()
{
	Node <E>* p = first;
	int n = size;
	while (n--)
	{
		cout << p->element << "->";
		p = p->next;
	}
	cout << endl;
}

template<class E>
Node<E>* Cirle_LinkList<E>::find_node(int index)		//找出某个节点
{
	if (index < 0 || index >= size)		//对于index都要进行规范性检测
	{
		cout << "index不规范" << endl;
		throw "index不符合规范";
	}
	Node<E>* node = first;
	for (int i = 0; i < index; i++)
	{
		node = node->next;
	}
	return node;
}

main.cpp

#include "Circle_Link_list.h"
#include <iostream>

int main()
{
    Cirle_LinkList<int> clist;
    clist.add(11);
    clist.add(22);
    clist.add(33);
    clist.add(44);
    clist.print();
    clist.add(0,55);
    clist.add(2,66);
    clist.print();
    clist.add(clist.cacul_size(),77);
    clist.remove(0);
    clist.remove(2);
    clist.print();
    return 0;
}

附：
1.本博客是由学习小码哥视频所总结文章
2.代码都通过合格检测，请放心食用~

GXM.
关注
专栏目录
单向循环链表（C++实现）
qq_40159978的博客
10-26 310
#include<stdio.h> #include<stdlib.h> #define ERROR 0 #define OK 1 typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Li...
单向循环链表C++实现
weixin_70343234的博客
02-05 531
实现了单项循环链表的头插，尾插，指定位置插入元素的方法；实现了头删，尾删，指定位置删除元素的方法；实现了获取某个位置的元素的方法。实现了获取链表是否为空的方法；实现了获取链表长度方法；
c++实现单向循环链表
qq_36028321的博客
05-16 442
#include<iostream> using namespace std; template <class T> class Node { public: T data; Node<T>* next; }; template <class T> class CLinkList { public: CLinkList(); ~CLinkList(); int getLength() { return this->length; }; v
C++实现循环单链表
最新发布
w1277256813的博客
08-03 398
C++实现循环单链表
C++实现单向循环链表
wanglelelihuanhuan的专栏
09-10 449
#include #include using namespace std; typedef int DataType; struct LinkNode { DataType _data; LinkNode* _next; LinkNode(const DataType& x) :_data(x) ,_next(NULL) {} }; class Slist { publi
C++实现单循环链表
m0_55614270的博客
08-31 1072
C++实现单循环链表
大话数据结构 —— 单循环链表 C#、C++代码实现
TAOTAO
06-07 487
单循环链表 单向循环链表是单链表的另一种形式，其结构特点是链表中最后一个结点的指针不再是结束标记，而是指向整个链表的第一个结点，从而使单链表形成一个环。 和单链表相比，循环单链表的长处是从链尾到链头比较方便。当要处理的数据元素序列具有环型结构特点时，适合于采用循环单链表。 单循环链表的初始化操作：示意图 非空表示意图： 假如终端结点用尾指...
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3190
链表详解及完整实现
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
大话数据结构 —— 双向链表 C#、C++代码实现
TAOTAO
06-07 476
双向列表 双向链表是每个结点除后继指针外还有一个前驱指针。和单链表类同，双向链表也有带头结点结构和不带头结点结构两种，带头结点的双向链表更为常用；另外，双向链表也可以有循环和非循环两种结构，循环结构的双向链表更为常用。 双向链表相当于两个单向循环链表,双链表节点结构如下图示： 双链表节点比单链表多一个前驱指针域。 如下图是带头结点的双向循环链表的图示结构。双向循环链...
数据结构与算法--单向有序链表（C++实现）
DeeperBlue的博客
04-08 9880
线性表是基本的数据结构。一般有数组和链表两种常用实现形式。本文用C++实现有序链表。是C++、数据结构及算法学习的一个小小练习。供大家参考。
用C++实现单向循环链表的解决方法
09-05
本篇文章是对用C++实现单向循环链表的解决方法进行了详细的分析介绍，需要的朋友参考下
C/C++经典约瑟夫环问题——带头结点的单向循环链表
03-24
本程序是采用带头结点的单向循环链表写成的，当指针指到要出列的结点时，先输出结点的序列号，再删除之，直到所有结点都出列完
Josephus问题C++单循环链表实现
09-22
这个完全符合课本上习题的要求，我作业交的就是这个，我自己还在里面做了详细的注释
数据结构（C++）——单向循环链表
Anna的博客
01-20 432
#include"AllHead.h" template class CircList; template class CircListNode { friend class CircList; protected: T data; CircListNode *next; public: CircListNode(CircListNode *ptr = NULL){next = ptr
C++数据结构与算法——单向循环链表
卢然小子的博客
05-27 1292
单向循环链表：相对于单向链表的最后一个节点的next指针指向nullptr，单向循环链表的最后一个节点的next指针指向链表头。此处主要实现了单向循环链表的插入、删除、构造、析构、输出操作符等简单功能。注意：单向循环链表最主要关心的是插入、删除时头节点的更新问题。如，在链表头删除时需要将链表头指向下一个节点或者置为nullptr。
循环单向链表（c++实现）
echo_bright_的博客
02-02 3863
在单向链表（c++实现）中，链表的最后一个节点的nex指针指向NULL，而所谓的循环单向链表即是指链表的最后一个节点的next指针指向首节点(注意不是头节点，头节点是方便链表操作而存在的结构体变量)。循环链表是一种特殊的单向链表，因此软件设计上，循环链表可继承自单向链表。   循环单向链表的实现难点在于：   （1）插入数据的位置为0时，头节点和尾节点的next指针均指向新节点；   （2）
单向循环链表C++
李习的博客
07-16 285
#
单循环链表的C++实现
抚琴弹出情凋零的博客
08-19 653
仅供参考 #include <iostream> using namespace std; // 函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define MAXSIZE ...
数据结构课程设计：约瑟夫环与单向循环链表实现
在这个课程设计中，学生们的目标是通过实现一个完整的程序来深入理解和应用数据结构，特别是单向循环链表。该设计旨在配合《数据结构》课程的学习，让学生掌握算法编写、类C语言编程技巧以及如何将算法转化为实际的C...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GXM.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值