【数据结构】单向循环链表的实现

最新推荐文章于 2022-05-22 00:24:36 发布
最新推荐文章于 2022-05-22 00:24:36 发布
阅读量550 收藏 4
点赞数 2
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43737259/article/details/113759853
版权

不带头单向循环链表结构如下:
单向循环链表
其中，详细介绍不带头单向循环链表的排序功能的实现。
以以下链表为例：
在这里插入图片描述
第一步：
将该单向循环链表分成只有一个结点的单向循环链表p和由剩下结点组成的一个单向不循环链表q。
在这里插入图片描述
第二步：
将p指向q链表要比较的第一个结点，q用来保存下一个结点，prev用来保存要插入位置的前一个节点的位置，cur用来保存要插入位置的结点。
比较 1<2，并没有进入第二个while中，此时prev仍为NULL，故应该将结点头插进入该单向循环链表中，由于头插会改变头结点，而单向循环链表的尾结点会指向头结点，所以需要借助第三个循环找到尾结点，更新它所指向的头结点。
在这里插入图片描述
头插成功，重新置prev为NULL，cur指向头结点。
在这里插入图片描述
第三步：
由于 4>1 且 4>2，故cur由结点1->结点2->结点1，prev由NULL->结点1->结点2，此时cur再次指向头结点，第二个循环结束，所以结点4需要插入在最后一个结点和第一个结点之间，也就是尾插。
在这里插入图片描述
尾插成功，重新置prev为NULL，cur指向头结点。
在这里插入图片描述
第四步：
由于 3>1且3>2，故cur由结点1->结点2->结点4，prev由NULL->结点1->结点2，此时cur指向的结点4>当前p结点即结点3，所以第二个循环结束。将结点3插入在prev和cur之间。
在这里插入图片描述
插入成功，整个排序工作也就完成了。
在这里插入图片描述
具体实现的代码如下;

void SCListSort(SCList* phead)
{
	assert(phead != NULL);
	if (SCListLength(*phead) == 1 || SCListLength(*phead)== 0)
		return;
	SCListNode* p = *phead;
	SCListNode* q = (*phead)->next;
	p->next = *phead;
	//将该单向循环链表分成只有一个结点的单向循环链表p和由剩下结点组成的一个单向不循环链表q。
	SCListNode* node = q;
	while (node->next != *phead)
		node = node->next;
	node->next = NULL;

	SCListNode* cur = *phead;
	SCListNode* prev = NULL;
	//第一个循环，用以保存所需插入到已有序的单向循环链表中的结点。
	while (q != NULL)
	{
		p = q;
		q = q->next;

		while (cur != NULL && cur->data < p->data)//第二个循环，寻找所需插入结点的位置和其前一个位置
		{
			prev = cur;
			cur = cur->next;
			if (cur == *phead)
				break;
		}
		if (prev == NULL)//头插
		{
			SCListNode* last = *phead;
			//第三个循环，用以找到单向循环链表的尾结点，以更新其指向的头结点
			while (last->next != *phead)
				last = last->next;
			p->next = *phead;
			*phead = p;
			last->next = *phead;
		}
		else
		{
			prev->next = p;
			p->next = cur;
		}
		prev = NULL;
		cur = *phead;
	}
}

单向循环链表各个功能实现如下：

//sclist.h
#pragma once
#include"commen.h"

#define ElemType int
typedef struct SCListNode
{
	ElemType data;
	struct SCListNode* next;
}SCListNode;

typedef SCListNode* SCList;

void SCListInit(SCList* phead);
void SCListDestroy(SCList* phead);
void SCListShow(SCList phead);
void SCListPushBack(SCList* phead, ElemType x);
void SCListPushFront(SCList* phead, ElemType x);
void SCListPopBack(SCList* phead);
void SCListPopFront(SCList* phead);
size_t SCListLength(SCList phead);
SCListNode* SCListFind(SCList phead, ElemType key);
void SCListEraseByVal(SCList* phead, ElemType key);
void SCListSort(SCList* phead);
void SCListInsertByVal(SCList* phead, ElemType x);
ElemType SCListFront(SCList* phead);
ElemType SCListBack(SCList* phead);
void SCListEraseAll(SCList* phead, ElemType x);
void SCListClean(SCList* phead);
void SCListReverse(SCList* phead);
///
void SCListInit(SCList* phead)
{
	*phead = NULL;
}
void SCListShow(SCList phead)
{
	SCListNode* cur = phead;
	if (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
		while (cur != NULL && cur != phead)
		{
			printf("%d->", cur->data);
			cur = cur->next;
		}
	}
	printf("over\n");
}

void SCListPushBack(SCList* phead, ElemType x)
{
	assert(phead != NULL);
	SCListNode* node = (SCListNode*)malloc(sizeof(SCListNode));
	assert(node != NULL);
	node->data = x;
	SCListNode* cur = *phead;
	if (cur == NULL)//插入的结点是第一个结点
		*phead = node;
	else
	{
		while (cur->next != *phead)
			cur = cur->next;
		cur->next = node;
	}
	node->next = *phead;//最后一个结点指向头部
}
void SCListPushFront(SCList* phead, ElemType x)
{
	assert(phead != NULL);
	SCListNode* node = (SCListNode*)malloc(sizeof(SCListNode));
	node->data = x;
	SCListNode* last = *phead;
	if (*phead == NULL)//链表为空时进行头插
	{
		*phead = node;
		node->next = *phead;
	}
	else
	{
		//找到最后一个结点
		while (last->next != *phead)
			last = last->next;
		node->next = *phead;
		*phead = node;
		last->next = *phead;
	}
}
void SCListPopBack(SCList* phead)
{
	assert(phead != NULL);
	if (*phead == NULL)
		printf("当前链表为空，无法进行删除操作\n");
	else if (SCListLength(*phead) == 1)//只有一个结点
	{
		free(*phead);
		*phead = NULL;
	}
	else
	{
		SCListNode* cur = *phead;
		SCListNode* prev = NULL;
		while (cur->next != *phead)
		{
			prev = cur;
			cur = cur->next;
		}
		free(cur);
		cur = NULL;
		prev->next = *phead;
	}
}
void SCListPopFront(SCList* phead)
{
	assert(phead != NULL);
	if (*phead == NULL)
		printf("当前链表为空，无法进行删除操作\n");
	else if (SCListLength(*phead) == 1)
	{
		free(*phead);
		*phead = NULL;
	}
	else
	{
		SCListNode* cur = *phead;
		SCListNode* newhead = cur->next;
		while (cur->next != *phead)
			cur = cur->next;
		cur->next = newhead;
		free(*phead);
		*phead = newhead;
	}
}
size_t SCListLength(SCList phead)
{
	if (phead == NULL)
		return 0;
	size_t len = 1;
	SCListNode* cur = phead->next;
	while (cur != NULL && cur != phead)
	{
		cur = cur->next;
		++len;
	}
	return len;
}
void SCListDestroy(SCList* phead)
{
	assert(phead != NULL);
	SCListNode* cur = *phead;
	while (*phead != NULL)
	{
		SCListPopBack(phead);
	}
}
SCListNode* SCListFind(SCList phead, ElemType key)
{
	assert(phead != NULL);
	SCListNode* cur = phead;
	while (cur != NULL && cur->data != key)
	{
		cur = cur->next;
		if (cur->next == phead)
			return NULL;
	}
	return cur;
}
void SCListEraseByVal(SCList* phead, ElemType key)
{
	assert(phead != NULL);
	if (*phead == NULL)
		printf("该链表为空，无法进行删除操作\n");
	else if((*phead)->data == key)
	{
		SCListPopFront(phead);
	}
	else
	{
		SCListNode* cur = *phead;
		SCListNode* prev = NULL;
		while (cur->data != key)
		{
			if (cur->next == *phead)
			{
				printf("该链表中没有元素%d,无法进行删除操作\n", key);
				return;
			}
			prev = cur;
			cur = cur->next;
		}
		if (cur->next == *phead)
			SCListPopBack(phead);
		else
		{
			prev->next = cur->next;
			free(cur);
			cur = NULL;
		}
	}
}
ElemType SCListFront(SCList* phead)
{
	assert(phead != NULL);
	if (*phead == NULL)
		return -1;
	else
		return (*phead)->data;
}
ElemType SCListBack(SCList* phead)
{
	assert(phead != NULL);
	if (*phead == NULL)
		return -1;
	else
	{
		SCListNode* cur = *phead;
		while (cur->next != *phead)
			cur = cur->next;
		return cur->data;
	}
}
void SCListSort(SCList* phead)
{
	assert(phead != NULL);
	if (SCListLength(*phead) == 1 || SCListLength(*phead)== 0)
		return;
	SCListNode* p = *phead;
	SCListNode* q = (*phead)->next;
	p->next = *phead;
//将该单向循环链表分成只有一个结点的单向循环链表p和由剩下结点组成的一个单向不循环链表q。
	SCListNode* node = q;
	while (node->next != *phead)
		node = node->next;
	node->next = NULL;

	SCListNode* cur = *phead;
	SCListNode* prev = NULL;
	while (q != NULL)//第一个循环，用以保存所需插入到已有序的单向循环链表中的结点。
	{
		p = q;
		q = q->next;

		while (cur != NULL && cur->data < p->data)//第二个循环，寻找所需插入结点的位置和其前一个位置
		{
			prev = cur;
			cur = cur->next;
			if (cur == *phead)
				break;
		}
		if (prev == NULL)//头插
		{
			SCListNode* last = *phead;
			while (last->next != *phead)//第三个循环，用以找到单向循环链表的尾结点，以更新其指向的头结点
				last = last->next;
			p->next = *phead;
			*phead = p;
			last->next = *phead;
		}
		else
		{
			prev->next = p;
			p->next = cur;
		}
		prev = NULL;
		cur = *phead;
	}
}
void SCListInsertByVal(SCList* phead, ElemType x)
{
	assert(phead != NULL);
	SCListNode* node = (SCListNode*)malloc(sizeof(SCListNode));
	node->data = x;
	if (SCListLength(*phead) == 0)
		SCListPushFront(phead, node);
	else
	{
		SCListNode* cur = *phead;
		SCListNode* prev = NULL;
		while (cur->data < x)
		{
			prev = cur;
			cur = cur->next;
			if (cur == *phead)
				break;
		}
		if (prev == NULL)//头插
		{
			SCListNode* last = *phead;
			while (last->next != *phead)
				last = last->next;
			node->next = *phead;
			*phead = node;
			last->next = *phead;
		}
		else
		{
			node->next = cur;
			prev->next = node;
		}
	}
}
void SCListEraseAll(SCList* phead, ElemType x)
{
	assert(phead != NULL);
	if (*phead == NULL)
	{
		printf("当前链表为空，无法进行删除操作\n");
	}
	else
	{
		SCListNode* cur = *phead;
		SCListNode* node = NULL;
		while (cur->next != *phead)
			cur = cur->next;
		cur->next = NULL;//将循环暂时断开，方便删除结点
		while (*phead != NULL && (*phead)->data == x)
		{
			node = *phead;
			*phead = node->next;
			free(node);
			node = NULL;
		}
		if (*phead == NULL)
			return;
		cur = *phead;
		SCListNode* prev = NULL,* next = cur->next;
		while (cur != NULL)
		{
			if (cur->data == x)
			{
				free(cur);
				cur = prev;
				prev->next = next;
			}
			prev = cur;
			cur = next;
			if(cur != NULL)
				next = cur->next;
		}
		prev->next = *phead;//重新连接头部
	}
}
void SCListClean(SCList* phead)
{
	SCListDestroy(phead);
}
void SCListReverse(SCList* phead)
{
	assert(phead != NULL);
	if (SCListLength(*phead) == 1 || SCListLength(*phead) == 0)
		return;
	SCListNode* p = *phead;
	SCListNode* q = p->next;

	SCListNode* last = q;
	while (last->next != *phead)
		last = last->next;
	last->next = NULL;
	p->next = *phead;//分成单向循环链表p和单链表q

	while (q != NULL)//将q中的结点一次头插入p中
	{
		p = q;
		q = q->next;

		last = *phead;
		while (last->next != *phead)
			last = last->next;
		p->next = *phead;
		*phead = p;
		last->next = *phead;
	}
}

对单向循环链表各个功能的测试模块如下：

//test.c
#define _CRT_SECURE_NO_WARNINGS

#include"commen.h"
#include"sclist.h"
int main()
{
	SCList list;
	SCListInit(&list);

	SCListNode* p = NULL;
	ElemType item;
	int select = 1;
	size_t pos;
	while (select)
	{
		printf("**************************************************\n");
		printf("***********************MENU***********************\n");
		printf("*  [1]push_back                   [2]push_front  *\n");
		printf("*  [3]show_list                   [0]quit_system *\n");
		printf("*  [4]pop_back                    [5]pop_front   *\n");
		printf("*  [6]insert_val                  [7]erase_val   *\n");
		printf("*  [8]find                        [9]length      *\n");
		printf("*  [10]earse_all                  [11]sort       *\n");
		printf("*  [12]reverse                    [13]clean      *\n");
		printf("*  [14]front                      [15]back       *\n");
		printf("**************************************************\n");
		printf("**************************************************\n");
		printf("请选择->\n");
		scanf("%d", &select);
		if (select == 0)
			break;
		switch (select)
		{
		case 0:
			select = 0;
			break;
		case 1:
			printf("请输入要插入的元素，若要退出，输入-1->\n");
			while (scanf("%d", &item), item != -1)
			{
				SCListPushBack(&list, item);
			}
			break;
		case 2:
			printf("请输入要插入的元素，若要退出，输入-1->\n");
			while (scanf("%d", &item), item != -1)
			{
				SCListPushFront(&list, item);
			}
			break;
		case 3:
			SCListShow(list);
			break;
		case 4:
			SCListPopBack(&list);
			break;
		case 5:
			SCListPopFront(&list);
			break;
		case 6:
			printf("请输入要插入的元素->\n");
			scanf("%d", &item);
			SCListSort(&list);
			SCListInsertByVal(&list, item);
			break;
		case 7:
			printf("请输入要删除的元素->\n");
			scanf("%d", &item);
			SCListEraseByVal(&list, item);
			break;
		case 8:
			printf("请输入要查找的元素->\n");
			scanf("%d", &item);
			p = SCListFind(list, item);
			if (p == NULL)
				printf("元素%d不存在\n", item);
			else
				printf("元素%d所在的位置为%d", item, p);
			break;
		case 9:
			printf("length = %d\n", SCListLength(list));
			break;
		case 10:
			printf("请输入要删除的元素->\n");
			scanf("%d", &item);
			SCListEraseAll(&list, item);
			break;
		case 11:
			SCListSort(&list);
			break;
		case 12:
			SCListReverse(&list);
			break;
		case 13:
			SCListClean(&list);
			break;
		case 14:
			if (SCListFront(&list) == -1)
				printf("该顺序表为空，无法获取其头部元素\n");
			else
				printf("头元素为%d\n", SCListFront(&list));
			break;
		case 15:
			if (SCListBack(&list) == -1)
				printf("该顺序表为空，无法获取其尾部元素\n");
			else
				printf("末尾元素为%d\n", SCListBack(&list));
			break;
		default:
			printf("输入非法，请重新选选择->\n");
			break;
		}
		system("pause");
		system("cls");
	}
	SCListDestroy(&list);
	return 0;
}
柳阿九
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【数据结构与算法】之单向循环链表的创建/遍历/插⼊/查找/删除算法实现
╰つ栺尖篴夢ゞ
08-06 1191
循环链表是一个收尾相接的链表，将单链表的最后一个指针域改由NULL改为指向表头结点这就是单链式的循环链表，并称为循环单链表。 带头结点的循环单链表的各种操作的算法实现与带头结点单链表的算法实现类似，差别仅在于算法判别当前结点p是否为尾结点的条件不同。单链表中的判别条件为p!=NULL或p->next!=NULL，而单循环链表判别条件是p!=L或p->next!=L。 在循环单链表中附设尾指针有时候比附设头指针更简单。
数据结构手把手教学——单向循环链表
Sanjay_Wu的博客
12-08 750
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构单向循环链表。
如何创建单链表以及循环链表
triggerV的博客
02-10 1878
在这里插入代码片@[TOC](这里写#### 标题 标题定义目录标题) 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式
循环链表的实现
m0_49218627的博客
05-22 704
循环单链表的基本算法实现几乎和单链表一致，所不同的时候就是表尾的判断其中会导致操作不同，所要牢记的一点是正是因为 循环单链表是一个环，所以初始化的时候next指针要指向自己，同时任何位置上的插入和删除都是等价的，无需判断是否在表尾 这里主要实现一下几个和单链表有差别的地方 循环双链表的定义 typedef int ElemType; //为什么交cs呢circularsingle，真是取名鬼才 typedef struct CsNode { ElemType data; // 存放结点的.
单向循环链表实现
xinyuanjieyiwife的博客
10-16 204
public class SingleCircularLists { //初始化头结点 private Node header = null; //创建size用来计算链表长度 private int size = 0; //封装结点型内部类 class Node{ //数据域 Object o; //指针域 Node next; public Node(Object o) { this.o = o; } } //添加操作 private Boolean add(Object
数据结构：单向循环链表源码
07-04
数据结构：单向循环链表源码，为了让读者有更好的体验，把源码上传上去，有任何问题，或者有任何bug可以直接私信我，我会及时回复，并且解决对应问题
用单向循环链表模拟约瑟夫环
04-16
用C语言编写的约瑟夫环问题解决程序，利用单向循环链表存储结构模拟此过程
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
实现单链表类、单向循环链表类、双向循环链表类并进行正确性测试。
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
单向循环链表（Circular-Linked-list）
11-28
单向循环链表代码，参考我的博客：https://blog.csdn.net/weixin_45571585/article/details/127724891?spm=1001.2014.3001.5502
航班订票系统（单向，双向循环链表）
03-26
用单向链表存储航班信息，双向链表存储乘客信息，并可以订票，退票和查询的航班订票系统！
创建有序的单循环链表，并合并两个有序的单循环链表，并返回的是尾结点
11-12
合并有序单循环链表，不重新申请存储空间； 创建有序单循环链表，并指向尾结点； 新单循环链表的指针指向尾结点；
单循环链表的C++实现
抚琴弹出情凋零的博客
08-19 622
仅供参考 #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++单链表以及循环单链表的实现以及操作
HZPHYT的博客
02-15 1330
 单链表: #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; typedef struct node{ int data; node* next; }Node,*PNode; int getlen(PNode pn){ int i=0; PNode p=pn-&gt;next; while(p!=NULL){ i++; p=p-&g...
循环单链表的实现
So_discrepancy的博客
10-24 518
定义：将单链表中终端节点的指针端有空指针改为头节点，就使整个单链表形成一个环，这种头尾相接的单链表成为单循环链表。#include "string.h" #include "ctype.h"#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h"#define OK 1 #de
单链表系列教程三：循环创建单链表
qq_44131760的博客
03-23 2128
如果你掌握以下知识，可能会对理解此片文章有所帮助： 1.C语言的基本语法，及指针的简单使用 2.完全理解教程二的原理 写在前面的话： 接下来的教程可能会非常难以理解，因此我用了差不多整整一天时间来理解别人写的C语言循环创建单链表的原理。所以如果你一时读不懂，不要担心，你可以在纸上演算，慢慢体会，这需要一个过程。 然后此篇文章与其他单链表文章不同的是，省略了单链表的操作，专注于循环创建链表的工作。对于链表的基本操作，可能会在下篇文章叙述。 C语言语法不太熟练也没关系，我上一次用C是在一年前，也是写数据结构。语
链表——单向循环链表的实现
DuMarch的博客
12-30 206
单向循环链表 1.示意图： 2.单向循环链表节点的结构 private static class Entry<T> { private T value; private Entry<T> next; public Entry(T value) { this.value = value;...
初学链表———单向链表创建
qq_44001832的博客
11-09 1912
初学链表之单向链表创建 链表是由一个个节点构成的，而每一个节点都可以看成两个部分组成，分别是数据域和指针域，链表是由不是连续的地址空间组成的非线性存储结构，字面意思，他们不是一个连串的地址空间，那么我们想让他们能被顺序访问，就得用指针来分别访问他们的地址空间，这就是指针域的功能 创建结构体类型 在这里v插入代码片v ...
算法—详细讲解单向循环链表的实现（python）
python全栈
11-12 818
单向循环列表如图所示 单向循环链表的实现 一、往链表头部添加一个节点值为4 1、新增一个节点node=Node(4) 如果链表中的值为空：头节点指向新建节点node，新建的节点node的指针域指向头节点 if self.is_empty(): self.head=node node.next=self.head else: 先让node指针域指向当前链表的头节点 node.next=self.head 再让链表的尾节点指向node cur=self.head while cur.next!=self.
数据结构与算法单向循环链表
最新发布
09-20
在单向循环链表中，每个节点除了保存数据元素本身的信息外，还保存了指向下一个节点的指针。这样就可以通过遍历从一个节点到达下一个节点，并且当遍历到最后一个节点时，可以通过指向头节点的指针回到链表的起始位置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值