【c++版数据结构】之循环单链表的实现（带头结点以及尾节点）

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

所实现的循环单链表的结构如下图所示：


循环单链表的实现，和上一篇文章单链表的实现大致相同点击打开链接，略有区别：

1：循环判断的条件不再是s == NULL或者s->next == NULL,而是他们是否等于头指针。2: 断开链表时的处理，尾节点的next不是NULL，而是指向头结点

具体细节参考上一篇文章微笑

头文件：SCList.h

#ifndef SCLIST_H
#define SCLIST_H

#include<iostream>
#include<cassert>
using namespace std;

typedef enum{ FALSE, TRUE }Status;

template<class Type>
class List;

template<class Type>
class ListNode
{
	friend class List<Type>;
private:
	Type data;
	ListNode *next;
public:
	ListNode() :data(Type()), next(NULL){}
	ListNode(Type d, ListNode<Type> *n = NULL) :data(d), next(n){}
	void SetData(Type d){ data = d; }
	Type GetData()const{ return data; }
	~ListNode(){}
};

template<class Type>
class List
{
private:
	ListNode<Type> *first;
	ListNode<Type> *last;
	size_t         size;
public:
	List()
	{
		ListNode<Type> *s = new ListNode<Type>;
		assert(s != NULL);
		first = last = s;
		last->next = first;
	}
	~List()
	{
		destory();
	}
	Status push_back(const Type &x)
	{
		ListNode<Type> *s = new ListNode<Type>(x);
		if (s == NULL)
			return FALSE;
		last->next = s;
		last = s;
		last->next = first;
		size++;
		return TRUE;
	}
	void show_list()
	{
		ListNode<Type> *s = first->next;
		while (s != first)
		{
			cout << s->data << "->";
			s = s->next;
		}
		cout << "Nul." << endl;
	}
	Status push_front(const Type &x)
	{
		ListNode<Type> *s = new ListNode<Type>(x);
		if (s == NULL)
			return FALSE;
		s->next = first->next;
		first->next = s;
		if (size == 0)
		{
			last = s;
			last->next = first;//---------------->可以省略，think
		}
		size++;
		return TRUE;
	}
	Status pop_back()
	{
		if (size == 0)//
		{
			cout << "循环单链表已空，无法尾删" << endl;
			return FALSE;
		}
		ListNode<Type> *s = first;
		while (s->next != last)
			s = s->next;
		delete last;
		last = s;
		last->next = first;
		size--;
		return TRUE;
	}
	Status pop_front()
	{
		if (size == 0)//
		{
			cout << "循环单链表已空，无法头删" << endl;
			return FALSE;
		}
		ListNode<Type> *s = first->next;
		first->next = s->next;
		delete s;
		if (size == 1)
		{
			last = first;
			last->next = first;//可以省略-------------->
		}
		size--;
		return TRUE;
	}
	Status insert_val(const Type &x)
	{
		ListNode<Type> *s = first;
		while (s->next != first && s->next->data < x)
			s = s->next;
		if (s->next == first)
			push_back(x);
		else
		{
			ListNode<Type> *p = new ListNode<Type>(x);
			assert(p != NULL);
			p->next = s->next;
			s->next = p;
			size++;
		}
		return TRUE;
	}
	ListNode<Type>* find(const Type &x)
	{
		if (size == 0)
			return NULL;
		ListNode<Type> *s = first->next;
		while (s != first)
		{
			if (s->data == x)
				return s;
			s = s->next;
		}
		return NULL;
	}
	Status delete_val(const Type &x)
	{
		ListNode<Type> *s = find(x);
		if (s == NULL)
		{
			cout << "该元素不存在，无法删除" << endl;
			return FALSE;
		}
		if (s == last)
		{
			pop_back();
		}
		else
		{
			ListNode<Type> *p = s->next;
			s->data = p->data;
			s->next = p->next;
			if (p == last)//------------------->>注意
			{
				last = s;
			}
			delete p;
			size--;
		}
		return TRUE;
	}
	//从第一个节点处断开，一分为二，头结点和第一个节点成为一个单独的循环单链表
	//将剩余的节点依次按值插入该链表
	void sort()
	{
		if (size == 0 || size == 1)
			return;
		ListNode<Type> *s = first->next;
		ListNode<Type> *p = s->next;
		last = s;	
		last->next = first;
		while (p != first)
		{
			s = p;
			p = p->next;
			//insert_val(s->data);
			//delete s;
			ListNode<Type> *q = first;
			while (q->next != NULL && q->next->data < s->data)
			{
				q = q->next;
			}
			if (q->next == NULL)
			{
				last->next = s;
				last = s;
				last->next = first;
			}
			else
			{
				s->next = q->next;
				q->next = s;
			}
		}
	}
	//从第一个节点处断开，一分为二，头结点和第一个节点成为一个单独的循环单链表
	//将剩余的节点依次进行头插
	void reserve()
	{
		if (size == 0 || size == 1)
			return;
		ListNode<Type> *s = first->next;
		ListNode<Type> *p = s->next;
		last = s;
		last->next = first;
		while (p != first)
		{
			s = p;
			p = p->next;
			s->next = first->next;
			first->next = s;
		}
	}
	size_t lenth()
	{
		return size;
	}
	void clear()
	{
		if (size == 0)
			return;
		ListNode<Type> *s = first->next;
		while (s != first)
		{
			if (size == 1)
			{
				last = first;
				last->next = first;
			}
			else
			{
				first->next = s->next;
			}
			delete s;
			size--;
			s = first->next;
		}
	}
	ListNode<Type>* next(ListNode<Type> *s)
	{
		if (s == last)//最后一个节点没有后继
			return NULL;
		else
			return s->next;
	}
	ListNode<Type>* prio(ListNode<Type> *s)
	{
		if (s == first->next)//第一个节点没有前驱
			return NULL;
		ListNode<Type> *p = first;
		while (p->next != s)
		{
			p = p->next;
		}
		return p;
	}
	void destory()
	{
		clear();
		delete first;
		first = last = NULL;
	}
};
#endif
测试文件：main.cpp 

#include"SCList.h"

int main()
{
	List<int> mylist;
	int item;
	int n;
	int select = 1;
	//ListNode<int> *p;
	while (select)
	{
		cout << "*************************************** *" << endl;
		cout << "*[1] push_back           [2] push_front *" << endl;
		cout << "*[3] show_list           [4] pop_back   *" << endl;
		cout << "*[5] pop_front           [6] insert_val *" << endl;
		cout << "*[7] lenth               [8] find       *" << endl;
		cout << "*[9] merge               [10] delete_val*" << endl;
		cout << "*[11] sort               [12] reserve   *" << endl;
		cout << "*[13] next               [14] clear     *" << endl;
		cout << "*[15] prio               [0] quit_system*" << endl;
		cout << "请选择：>";
		cin >> select;
		switch (select)
		{
		case 1:
			cout << "请输入要插入的元素（-1结束):>";
			while (cin >> item, item != -1)
			{
				mylist.push_back(item);
			}
			break;
		case 2:
			cout << "请输入要插入的元素（-1结束）:>";
			while (cin >> item, item != -1)
			{
				mylist.push_front(item);
			}
			break;
		case 3:
			mylist.show_list();
			break;
		case 4:
			mylist.pop_back();
			break;
		case 5:
			mylist.pop_front();
			break;
		case 6:
			cout << "请输入要插入的元素：";
			cin >> item;
			mylist.insert_val(item);
			break;
		case 7:
			cout << "长度为：" << mylist.lenth() << endl;
			break;
		case 8:
			cout << "请输入要查找的元素：";
			cin >> item;
			if (mylist.find(item))
				cout << "it's found" << endl;
			else
				cout << "it's not exist" << endl;
			break;
		case 9:
			cout << "请输入要删除的位置：";
			cin >> n;
			//mylist.delete_pos(n,item);
			break;
		case 10:
			cout << "请输入要删除的元素：";
			cin >> item;
			mylist.delete_val(item);
			break;
		case 11:
			mylist.sort();
			break;
		case 12:
			mylist.reserve();
			break;
		case 13:
			cout << "请输入要查找后继的元素：";
			cin >> item;
			//p = mylist.next(item);
			//if (p != NULL)
			//	cout << p->GetData() << endl;
			break;
		case 14:
			mylist.clear();
			break;
		default:
			break;
		}
	}
	system("pause");
	return 0;
}



zyh_helen
关注
专栏目录
c++循环单链表
qq_48308055的博客
10-17 226
#include using namespace std; class node {public: int date; node* next; node(int a) { date=a; next=0; } }; class list {public: node* first; list() { first=0; } node* insert(int a) { node* p=first; if(first->date==0) first->date=a; else { node* n=new
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 3401
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
循环单链表C++实现
weixin_45645281的博客
01-19 173
#pragma once #ifndef Node_hpp #define Node_hpp typedef double value_data; class Node { public: value_data Data; Node *Next; }; #endif /* Node_hpp */ #pragma once #include "node.hpp" #include <iostream> using namespace std; class Circular_L
循环单向链表（c++实现）
echo_bright_的博客
02-02 3882
在单向链表（c++实现）中，链表的最后一个节点的nex指针指向NULL，而所谓的循环单向链表即是指链表的最后一个节点的next指针指向首节点(注意不是头节点，头节点是方便链表操作而存在的结构体变量)。循环链表是一种特殊的单向链表，因此软件设计上，循环链表可继承自单向链表。   循环单向链表的实现难点在于：   （1）插入数据的位置为0时，头节点和尾节点的next指针均指向新节点；   （2）
C++实现循环单链表
最新发布
w1277256813的博客
08-03 505
C++实现循环单链表
【数据结构】-单链表(带头结点）
RunningSnail的博客
07-18 2989
单链表-带头结点1.头文件及类型定义2.单链表结点类型定义3.函数声明4.基本操作4.1 初始化单链表4.2 判空4.3 插入操作4.3.1 按位插入4.3.2 指定结点插入4.3.2.1 指定结点后插4.3.2.2 指定结点前插4.3.2.2.1 前插法1(时间复杂度为O(n))4.3.2.2.2 前插法2(时间复杂的为O(1))4.4 删除操作4.4.1 按位删除4.4.2 指定结点删除4.4.2.1 删除法1(时间复杂度为O(n))4.4.2.2 删除法2(时间复杂度为O(1))4.5 查找操作4.5
【数据结构】单链表（不带头结点）基本操作的实现（C语言）
不 良的博客
11-12 1438
通过对顺序表的学习，我们可以发现顺序表有以下几点缺陷：1.空间不够时需要扩容，扩容尤其是用realloc进行异地扩容时，是有一定代价的，其次还可能存在一定空间浪费。 2.头部或者中间插入删除，需要挪动数据，效率低下。 那我们可以对其所具有的缺陷进行优化：可以按需申请空间同时插入删除时不挪动数据。而单链表就符合这些优化所具有特点。但是我们要注意的是单链表具有这些优点并不代表链表就可以完全替代顺序表。链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的……
C语言实现单链表（带头结点）的基本操作
03-25
单链表是数据结构中的一种基础类型，它...这些操作是单链表的基础，通过它们可以构建更复杂的链表数据结构和算法，例如双向链表、循环链表以及各种搜索和排序算法。在实际编程中，理解并熟练运用这些操作是至关重要的。
数据结构之单链表（带头节点）
mly15191882818的博客
08-04 2179
今天来聊聊单链表。单链表是以节点存的链式结构，分为带头节点和不带头节点的单链表。单链表中的节点包括data域和next域，data域存储元素的值，next域则存储下一个节点的地址。单链表中的各个节点在内存中不一定是连续存储的，存储形式如下图所示： 从图中可以看出，单链表中的各个节点并不是连续存储的。带头结点的单链表结构图如下图所示： 聊完单链表的基本知识，下面以对明星节点的增删改查操作为案例，实现对单链表的增删改查操作。 先说明节点结构： public class Node { p
c++实现的循环链表
04-09
使用c++实现的循环链表程序，供大家学习数据结构参考使用
数据结构 带头结点的单链表 操作大全 最全的链表操作（c++实现）
09-27
1800多行代码 22个功能 最全的链表操作 如需转载请注明出处 我的博文：http://blog.csdn.net/u012350104 欢迎交流 讲解代码中函数的ppt：http://download.csdn.net/detail/u012350104/9143181 Made By Fred韩
C++循环链表的实现
05-23
C++循环链表的实现，内含.h和.cpp文件各一个，导入IDE自动生成解决方案即可
c++实现循环单链表
weixin_45548868的博客
04-01 905
#include <iostream> using namespace std; #define MAXSIZE 20 #define TRUE 1 #define FALSE 0 typedef bool Status; /* Status是函数的类型,其值是函f数结果状态代码*/ typedef char ElemType; /* ElemType...
C++ 数据结构——循环单链表（尾指针）
qq_45875966的博客
03-22 1212
/* 循环单链表的实现 */ #include<iostream> using namespace std; template<typename T> struct Node { T data; Node<T>*next; }; template<typename T> class CircleLink { private: Node<T>* rear; public: CircleLink(); Cir
数据结构之单循环链表C++（模板）
Fay
05-07 1106
#ifndef STL_LINK_CIRCLELIST_H #define STL_LINK_CIRCLELIST_H /************************************************************************/ /* 以下是单循环链表C++实现 /**********************************************
C++实现单循环链表
m0_55614270的博客
08-31 1108
C++实现单循环链表
循环链表的C++实现
zcawesome的博客
04-10 3689
今天在单链表的基础上实现了循环链表其实只需要加上一个从任意位置输出表再稍微改动一下其他位置把最后一个结点的指针指向头结点就可以了//循环链表 #include&lt;iostream&gt; #include&lt;cstdlib&gt; using namespace std; struct node{ int data1; node *next; }; class singlelink...
2.3.2 带头尾节点的单循环链表——严蔚敏
C_cai_niao的博客
12-17 397
1、类型定义 typedef struct node { int ele; struct node* next; }S_NODE; typedef struct { S_NODE* head; S_NODE* tail; int length; }S_LIST; 2、初始化 void InitList(S_LIST* list) { list->head = NULL; ...
线性表的链式实现：不带头结点与带头结点的单链表
"本文主要介绍了表的几种链式实现方式，包括不带头结点的单链表、带头结点的单链表、循环单链表、双链表以及双向循环链表。这些实现方法是数据结构中表的常用存储结构，它们在不同的场景下有各自的优势和适用性。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值