单向循环链表的定义与实现

最新推荐文章于 2021-07-24 08:09:35 发布
最新推荐文章于 2021-07-24 08:09:35 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TianYanRen111/article/details/110010263
版权

单向循环链表

说明1：以下代码在VS2017中编译通过，读者使用时可以直接将头文件(CLinkList.h),源文件(CLinkList.c)，主文件(main.c)中的内容直接拷贝过去，即可编译运行！

说明2：图示在这里插入图片描述

头文件：CLinkList.h(函数的声明)

#ifndef  _CLINKLIST_H_
#define _CLINKLIST_H_
#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <stdbool.h>

#define ElemType int 
typedef struct ListNode
{
	ElemType data;
	struct ListNode* next;				
}ListNode,*pListNode;

typedef struct LinkList
{
	pListNode head;
	pListNode tail;
	size_t size;
}LinkList;

/
void InitList(LinkList* list);
ListNode* CreateNode(ElemType data);
void push_back(LinkList* list, ElemType data);
void push_front(LinkList* list, ElemType data);
void ShowList(LinkList* list);
void pop_back(LinkList* list);
void pop_front(LinkList* list);
bool Empty(LinkList* list);
void Insert_By_Value(LinkList* list, ElemType data);
pListNode Find_data(LinkList* list, ElemType Key);
int Length(LinkList* list);
void Delete_By_Value(LinkList* list, ElemType Key);
void Delete_By_Value_Traditaonal(LinkList* list, ElemType Key);
void Sort(LinkList* list);
void Reverse(LinkList* list);	//数据反转
void Clear(LinkList* list);
void Destory(LinkList* list);
pListNode Find(LinkList* list, ElemType Key);
pListNode Prior(LinkList* list, ElemType PosData);		//求PosData结点的前驱
pListNode Next(LinkList* list, ElemType PosData);		//求PosData结点的后继


#endif // ! _CLINKLIST_H_

源文件：CLinkList.c(函数的定义)

#include "CLinkList.h"

void InitList(LinkList* list)
{
	list->head = list->tail = (pListNode)malloc(sizeof(ListNode));
	assert(list->head != NULL);
	list->tail->next = list->head;
	list->size = 0;
}

ListNode * CreateNode(ElemType data)
{
	ListNode* NewNode = (pListNode)malloc(sizeof(ListNode));
	assert(NewNode != NULL);
	NewNode->data = data;
	NewNode->next = NULL;
	return NewNode;
}

void push_back(LinkList* list, ElemType data)
{
	pListNode NewNode = CreateNode(data);
	list->tail->next = NewNode;
	list->tail = NewNode;
	list->tail->next = list->head;
	list->size++;
}

void push_front(LinkList* list, ElemType data)
{
	pListNode NewNode = CreateNode(data);
	NewNode->next = list->head->next;
	list->head->next = NewNode;
	if (list->size == 0)
		list->tail = NewNode;
	list->size++;
}

void ShowList(LinkList* list)
{
	pListNode pMove = list->head->next;
	while (pMove != list->head)
	{
		printf("%d--->", pMove->data);
		pMove = pMove->next;
	}
	printf(".Nul\n");
}

void pop_back(LinkList* list)
{
	if (list->size == 0)
		return;
	pListNode pMove = list->head;
	while (pMove->next != list->tail)
	{
		pMove = pMove->next;
	}
	free(list->tail);
	list->tail = pMove;
	list->tail->next = list->head;
	list->size--;
}

void pop_front(LinkList* list)
{
	if (list->size == 0)
		return;
	pListNode pMove = list->head->next;
	list->head->next = pMove->next;
	free(pMove);
	if (list->size == 1)
		list->tail = list->head;
	list->size--;
}

bool Empty(LinkList* list)
{
	return list->size == 0;
}

void Insert_By_Value(LinkList* list, ElemType data)
{
	pListNode pMove = list->head;
	while (pMove->next != list->tail && pMove->next->data < data)
	{
		pMove = pMove->next;
	}
	if (pMove->next == list->tail && pMove->next->data < data)	//最后面插入
	{
		push_back(list, data);
	}
	else
	{
		pListNode NewNode = CreateNode(data);
		NewNode->next = pMove->next;
		pMove->next = NewNode;
		list->size++;
	}
}

pListNode Find_data(LinkList* list, ElemType Key)
{
	if (list->size == 0)
		return NULL;
	pListNode pMove = list->head->next;
	while (pMove != list->head && pMove->data != Key)
	{
		pMove = pMove->next;
	}
	if (pMove == list->head)
		return NULL;
	return pMove;
}

int Length(LinkList* list)
{
	return list->size;
}

void Delete_By_Value(LinkList* list, ElemType Key)
{
	if (list->size == 0)
		return;
	pListNode pFind = Find_data(list, Key);
	if (pFind == NULL)
	{
		printf("查无此数，无法删除！\n");
		return;
	}
	if (pFind == list->tail)
	{
		pop_back(list);
	}
	else if (pFind->next == list->tail)		//倒数第二个结点（必须单独考虑，list->tail指向要发生改变）
	{
		pListNode q = pFind->next;
		pFind->data = q->data;
		pFind->next = q->next;
		list->tail = pFind;
		free(q);
		q = NULL;
		list->size--;
	}
	else
	{
		pListNode q = pFind->next;
		pFind->data = q->data;
		pFind->next = q->next;
		if (pFind->next == list->tail)
			list->tail = pFind;
		free(q);
		q = NULL;
		list->size--;
	}
}

void Delete_By_Value_Traditaonal(LinkList* list, ElemType Key)
{
	if (list->size == 0)
		return;
	pListNode pFind = Find_data(list, Key);
	if (pFind == NULL)
	{
		printf("查无此数，无法删除！\n");
		return;
	}
	if (pFind == list->head->next)	//删除的是第一个结点
		pop_front(list);
	else if (pFind == list->tail)	//删除的是最后一个结点
		pop_back(list);
	else
	{
		pListNode pPrior = Prior(list, pFind->data);
		pPrior->next = pFind->next;
		free(pFind);
		pFind = NULL;
		list->size--;
	}
}

void Sort(LinkList* list)
{
	if (list->size == 0 || list->size == 1)
		return;
	//首先分割
	pListNode pMove1 = list->head->next;
	pListNode pMove2 = pMove1->next;
	list->tail->next = NULL;
	list->tail = pMove1;
	list->tail->next = list->head;
	//然后进行插入及其连接
	while (pMove2 != NULL)
	{
		pMove1 = pMove2;
		pMove2 = pMove2->next;

		pListNode pMove = list->head;
		while (pMove->next != list->tail && pMove->next->data < pMove1->data)
		{
			pMove = pMove->next;
		}
		if (pMove->next == list->tail && pMove->next->data < pMove1->data)
		{
			pMove1->next = list->tail->next;
			list->tail->next = pMove1;
			list->tail = pMove1;
		}
		else
		{
			pMove1->next = pMove->next;
			pMove->next = pMove1;
		}
	}
}

void Reverse(LinkList* list)
{
	if (list->size == 0 || list->size == 1)
		return;
	pListNode pMove1 = list->head->next;
	pListNode pMove2 = pMove1->next;
	list->tail->next = NULL;
	list->tail = pMove1;
	list->tail->next = list->head;
	while (pMove2 != NULL)
	{
		pMove1 = pMove2;
		pMove2 = pMove2->next;
		pMove1->next = list->head->next;
		list->head->next = pMove1;
	}
}

void Clear(LinkList* list)
{
	if (list->size == 0)
		return;
	pListNode pMove = list->head->next;
	while (pMove != list->head)
	{
		list->head->next = pMove->next;
		free(pMove);
		pMove = list->head->next;
	}
	list->tail = list->head;
	list->size = 0;
}

void Destory(LinkList* list)
{
	Clear(list);
	free(list->head);
	list->head = list->tail = NULL;
}

pListNode Find(LinkList* list, ElemType Key)
{
	ListNode* pFind = Find_data(list, Key);
	if (pFind == NULL || list->size == 0 || list->size == 1 || list->head->next->data == Key)
		return NULL;
	pListNode pMove = list->head->next;
	while (pMove->next != list->head && pMove->next->data != Key)
	{
		pMove = pMove->next;
	}
	return pMove;
}

pListNode Prior(LinkList* list, ElemType PosData)
{
	return Find(list,PosData);
}

pListNode Next(LinkList* list, ElemType PosData)
{
	ListNode* pFind = Find_data(list, PosData);
	if (pFind == NULL)
		return NULL;
	if (pFind->next == list->head)
		return NULL;
	return pFind->next;
}

主文件：main.c(测试文件)

#include "CLinkList.h"

int main()
{
	LinkList MyLinkList;
	InitList(&MyLinkList);
	push_back(&MyLinkList, 3);
	push_back(&MyLinkList, 1);
	push_back(&MyLinkList, 10);
	push_back(&MyLinkList, 7);
	ShowList(&MyLinkList);
	//push_front(&MyLinkList, 6);
	//push_front(&MyLinkList, 7);
	//push_front(&MyLinkList, 8);
	//ShowList(&MyLinkList);
	//pop_back(&MyLinkList);
	//pop_front(&MyLinkList);
	//ShowList(&MyLinkList);
	Insert_By_Value(&MyLinkList, 0);
	ShowList(&MyLinkList);
	//pListNode pFind = Find_data(&MyLinkList, 7);
	//Delete_By_Value(&MyLinkList, 7);
	//Delete_By_Value(&MyLinkList, 0);
	//Delete_By_Value(&MyLinkList, 3);
	ShowList(&MyLinkList);
	Sort(&MyLinkList);
	ShowList(&MyLinkList);
	Reverse(&MyLinkList);
	ShowList(&MyLinkList);
	//Clear(&MyLinkList);
	pListNode  pNext = Next(&MyLinkList, 10);//7
	pNext = Next(&MyLinkList, 3);//1
	pNext = Next(&MyLinkList, 0);//NULL

	pListNode pPrior = Prior(&MyLinkList, 10);//NULL
	pPrior = Prior(&MyLinkList, 3);//7
	pPrior = Prior(&MyLinkList, 0);//1
	Delete_By_Value_Traditaonal(&MyLinkList, 10);
	Delete_By_Value_Traditaonal(&MyLinkList, 3);
	Delete_By_Value_Traditaonal(&MyLinkList, 0);
	ShowList(&MyLinkList);
	return 0;
}
@十三阿哥
关注
专栏目录
【数据结构】循环双向链表定义和基本操作
Z_sea的博客
12-18 1310
循环双向链表： 循环双向链表的定义： typedef struct CDLNode{ LElemType data; struct CDLNode * pre; struct CDLNode * next; CDLNode(LElemType Data=0,struct CDLNode* Pre=NULL,struct CDLNode* Next=NULL){...
单向循环链表实现
hxy1625309592的博客
12-15 1501
1.1 基本介绍 循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结点，因为没有下一个元素了。要实现循环链表，只需要让单向链表的最后一个节点的指针指向头结点即可。 1.2 添加操作 1、思路分析 链表为空的时候 让head和tail同时指向这个结点，让尾结点的下一跳指向头结点。 头部添加 先让要添加的元素指向head,然后再将head指针指向新结点。 最后让tail指针下一跳重新指向头结点 尾部添加 直接让新结点的下一跳指
双向循环链表
日积月累
07-24 422
//双向循环链表 public class LinkedList implements List, Stack, Queue, Deque { private class Node { E data; Node pre; Node next; public Node(E data) { this.data = data; pre = null; next = null; } @Override public String toString() { return data.toString(); } } pr
数据结构基础(12) --双向循环链表的设计与实现
weixin_30289831的博客
01-06 115
双向链表的操作特点： (1)“查询”和单链表相同; (2)“插入”和“删除”时需要同时修改两个方向上的指针。 但是对于双向循环链表则在表尾插入非常的迅速,只需O(1)的时间,因为有指向前面的指针,因此双向循环链表会很容易的找到位于表尾的元素,因此双向循环链表比较适用于频繁在表尾插入的情况.空链表:双向循环链表节点构造:class DoubleListNode { pr...
python单向循环链表原理与实现方法示例
09-18
在Python中实现单向循环链表，我们通常需要定义两个类：`Node`表示链表中的节点，`SinCycLinkedlist`表示链表本身。`Node`类包含两个属性：`item`存储节点的值，`next`存储指向下一个节点的引用。`SinCycLinkedlist`...
单向循环链表实现约瑟夫环.zip
12-05
在提供的"单向循环链表实现约瑟夫环.txt"文件中，可能包含了具体的代码实现或者详细解释，包括节点定义、链表操作（如插入、删除）以及约瑟夫环算法的完整流程。通过阅读和理解这个文件，你可以深入学习如何将理论...
用C++实现单向循环链表的解决方法
09-05
在C++中实现单向循环链表涉及创建一个表示节点的结构体，定义链表类以及实现相关操作的方法。 首先，我们定义了一个模板结构体`NODE<T>`，用于表示链表中的节点。这个结构体包含两个成员：一个类型为`T`的数据域`...
Python实现的单向循环链表功能示例
09-21
与普通的单向链表不同，单向循环链表中的最后一个节点不是指向`None`，而是指向链表的第一个节点（即头节点），形成一个闭环。 ### 原理介绍 在单向循环链表中，每个节点包含两部分：数据域（用于存储实际数据）和...
单向循环链表
DAN_L的博客
02-26 256
一、定义 单向循环链表是单链表的一个变型，链表中最后一个节点的next域不再是None，而是指向链表的头节点。 二、操作 1、is_empty()判断链表是否为空 2、length()链表长度 3、travel()遍历整个链表 4、add(item)链表头部添加元素 5、append(item)链表尾部添加元素 6、insert(pos,item)指定位置添加元素 7、remove(item)删...
双向循环链表的定义以及基本操作 超详细！
qq_42890853的博客
06-28 1553
#include<stdio.h>//头文件 #include<stdlib.h>//头文件 malloc函数 struct node//结点结构体定义 { struct node* prior;//前指针 指向前一个节点 struct node* next;//后指针 指向后一个节点 int data; }; typedef struct node node;//为"struct node"起别名node 指结点 typedef struct node .
双向循环链表讲解及实现
热门推荐
DR5200的博客
04-10 1万+
文章目录一.带头双向循环链表二.实现(1).动态申请一个结点 一.带头双向循环链表 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个链表虽然结构复杂，但是使用代码实现以后会发现能带来很多优势. 二.实现 Lish.h中部分声明 (1).动态申请一个结点 ...
双向循环链表简介
Space_analyse的博客
09-18 2429
同单向链表比较，双向链表的优势在于查找的方便性； 单向循环链表仅对于该节点及后继结点的查找便利，但当查找结点前驱节 点时就遇到最高时间复杂度O（n），遍历一周； 双向循环链表则只需要O（1），详细代码如下； 定义链表结点 给出了两个指针prior 和 next，一个指向前驱结点，一个指向后继结点； struct DulNode{ string data; DulNode* prior; DulNode* next; DulNode():data(""),prior(nullptr.
单循环链表类的定义和实现
weixin_34167043的博客
05-04 205
ｃｉｒｌｉｎｋｌｉｓｔ．ｈ的重要性： ｔｙｐｅｄｅｆ ｉｎｔ ＥｌｅｍＴｙｐｅ ； ｔｙｐｅｄｅｆ ｓｔｒｕｃｔ Ｌｎｏｄｅ｛ ＥｌｅｍＴｙｐｅ ｄａｔａ； Ｌｎｏｄｅ ＊ｎｅｘｔ； ｝ＬＮｏｄｅ； ｃｌａｓｓ ｃｉｒｌｉｎｋｌｉｓｔ ｛ ｐｒｉｖａｔｅ ： ＬＮｏｄｅ ＊ ｈｅａｄ； ＬＮｏｄｅ ＊ ｃｕｒｒ； ...
多项式加法
chengren2016的博客
11-29 98
#include<iostream> #include<cmath> using namespace std; typedef struct node { int ratio;//系数 int index;//指数 struct node *n...
单向循环链表详解与C语言实现
在本资源中，我们深入探讨了单向循环链表的数据结构与操作。单向循环链表是一种线性数据结构，其中每个节点只包含一个指向下一个节点的指针，形成一个首尾相连的环形结构。这种数据结构在需要实现高效的插入和删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

@十三阿哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值