单向循环链表————查找、删除、插入结点 （基于C语言实现）

/*******************************************************************
 *
 *	file name:	CircularLinkedList.c
 *	author	 :  Dazz
 *	date	 :  2024/04/23
 *	function :  用于学习单向循环链表，并添加插入、删除、查找结点等函数
 * 	note	 :  None
 *
 *	CopyRight (c)  2024-202x   Dazz_24@163.com   All Right Reseverd
 *
 * *****************************************************************/

#include <stdio.h>
#include <stdbool.h>
// 指的是单向循环链表中的结点有效数据类型，用户可以根据需要进行修改
typedef int DataType_t;

// 构造单向循环链表的结点,链表中所有结点的数据类型应该是相同的
typedef struct CircularLinkedList
{
	DataType_t data;		 // 结点的数据域
	struct LinkedList *next; // 结点的指针域

} CircLList_t;

/******************************************************
 *
 *  name      : CircLList_Create
 *	function  : 创建一个空单向循环链表，空链表应该有一个头结点，对链表进行初始化
 *  argument  ：None
 *  retval    : 头结点的地址
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 创建一个空单向循环链表，空链表应该有一个头结点，对链表进行初始化
CircLList_t *CircLList_Create(void)
{
	// 1.创建一个头结点并对头结点申请内存
	CircLList_t *Head = (CircLList_t *)calloc(1, sizeof(CircLList_t));
	if (NULL == Head)
	{
		perror("Calloc memory for Head is Failed");
		exit(-1);
	}

	// 2.对头结点进行初始化，头结点是不存储数据域，指针域指向自身，体现“循环”思想
	Head->next = Head;

	// 3.把头结点的地址返回即可
	return Head;
}

/******************************************************
 *
 *  name      : CircLList_NewNode
 *	function  : 创建一个空单向循环链表，空链表应该有一个头结点，对链表进行初始化
 *  argument
 * 				@data :结点数据域的数据
 *
 *  retval    : 新结点的地址
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 创建新的结点，并对新结点进行初始化（数据域 + 指针域）
CircLList_t *CircLList_NewNode(DataType_t data)
{
	// 1.创建一个新结点并对新结点申请内存
	CircLList_t *New = (CircLList_t *)calloc(1, sizeof(CircLList_t));
	if (NULL == New)
	{
		perror("Calloc memory for NewNode is Failed");
		return NULL;
	}

	// 2.对新结点的数据域和指针域进行初始化
	New->data = data;
	New->next = NULL;

	return New;
}

/******************************************************
 *
 *  name      : CircLList_HeadInsert
 *	function  : 将新的结点插入在单向循环链表的头部
 *  argument
 *
 * 				@head : 头结点的地址
 * 			    @data : 结点数据域的数据
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 头插
bool CircLList_HeadInsert(CircLList_t *Head, DataType_t data)
{
	// 创建新的结点，并对结点初始化
	CircLList_t *New = CircLList_NewNode(data);

	// 判断链表是否为空
	if (Head == Head->next)
	{
		// 头结点的指针域指向新结点，新结点的指针域指向自己
		Head->next = New;
		New->next = New;

		return true;
	}

	// 将新结点的指针域指向链表的首结点
	New->next = Head->next;

	// 将头结点的指针域指向新结点
	Head->next = New;

	// 对单向循环链表的头结点的地址进行备份
	CircLList_t *Phead = Head;

	//  从首结点开始遍历,得到尾结点的地址
	while (Phead->next)
	{
		// 把头结点的直接后继作为新的头结点
		Phead = Phead->next;

		// 判断是否到达尾结点，尾结点的next指针是指向首结点的地址
		if (Phead->next == Head->next)
		{
			break;
		}
	}

	// 将尾结点的指针域指向新结点；
	Phead->next = New;

	return true;
}

/******************************************************
 *
 *  name      : CircLList_TailInsert
 *	function  : 将新的结点插入在单向循环链表的尾部
 *  argument
 *
 * 				@head : 头结点的地址
 * 			    @data : 结点数据域的数据
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 尾插
bool CircLList_TailInsert(CircLList_t *Head, DataType_t data)
{
	// 创建新的结点，并对结点初始化
	CircLList_t *New = CircLList_NewNode(data);

	// 判断链表是否为空
	if (Head == Head->next)
	{
		// 头结点的指针域指向新结点，新结点的指针域指向自己
		Head->next = New;
		New->next = New;

		return true;
	}

	//  对单向循环链表的头结点的地址进行备份
	CircLList_t *Phead = Head;

	//   遍历链表，找到尾结点
	while (Phead->next)
	{
		// 把头结点的直接后继作为新的头结点
		Phead = Phead->next;

		// 判断是否到达尾结点，尾结点的next指针是指向首结点的地址
		if (Phead->next == Head->next)
		{
			break;
		}
	}

	// 将尾结点的指针域指向新结点
	Phead->next = New;

	// 将新结点的指针域指向首结点
	New->next = Head->next;

	return true;
}

/******************************************************
 *
 *  name      : CircLList_DestInsert
 *	function  : 将新的结点插入在单向循环链表的指定位置
 *  argument

 * 				@head : 头结点的地址
 * 			    @data : 结点数据域的数据
 * 				@destval : 需要插入位置的结点的数据域
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 指定位置插入
bool CircLList_DestInsert(CircLList_t *Head, DataType_t destval, DataType_t data)
{
	// 创建新的结点，并对结点初始化
	CircLList_t *New = CircLList_NewNode(data);

	// 判断链表是否为空
	if (Head == Head->next)
	{
		// 头结点的指针域指向新结点，新结点的指针域指向自己
		Head->next = New;
		New->next = New;

		return true;
	}
	// 将头结点做备份
	CircLList_t *phead = Head;


	// 遍历链表，找到指定结点
	while (phead->next)
	{
		// 把头结点的直接后继作为新的头结点
		phead = phead->next;

		// 判断是否到达尾结点，尾结点的next指针是指向首结点的地址
		if (phead->data == destval)
		{
			break;
		}

		if (phead->next == Head->next)
		{
			break;
		}
	}

	if (Head->next == phead->next && destval != phead->data)
	{
		printf("列表中没有该数据\n");
		return false;
	}

	// 将新结点的指针域指向目标目标结点的直接后继
	New->next = phead->next;

	// 将目标结点的指针域指向新结点
	phead->next = New;

	return true;
}

/******************************************************
 *
 *  name      : CircLList_Print
 *	function  : 遍历并输出链表里每个结点的数据域
 *  argument
 * 				@head : 头结点的地址
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 遍历链表
bool CircLList_Print(CircLList_t *Head)
{
	// 对单向循环链表的头结点的地址进行备份
	CircLList_t *Phead = Head;

	// 判断当前链表是否为空，为空则直接退出
	if (Head->next == Head)
	{
		printf("current linkeflist is empty!\n");
		return false;
	}

	// 从首结点开始遍历
	while (Phead->next)
	{
		// 把头结点的直接后继作为新的头结点
		Phead = Phead->next;

		// 输出头结点的直接后继的数据域
		printf("data = %d\n", Phead->data);

		// 判断是否到达尾结点，尾结点的next指针是指向首结点的地址
		if (Phead->next == Head->next)
		{
			break;
		}
	}

	return true;
}

/******************************************************
 *
 *  name      : CircLList_HeadDel
 *	function  : 删除链表的首结点
 *  argument
 * 				@head : 头结点的地址
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 头删
bool CircLList_HeadDel(CircLList_t *Head)
{
	// 判断链表是否为空
	if (Head == Head->next)
	{
		printf("链表为空\n");
		return false;
	}


	// 对首结点的地址做备份；
	CircLList_t *temp = Head->next;
	
	//判断链表中是否只有首届点
	if(head->next == head->next->next)
	{
	temp->next = NULL;
	Head->next = Head;
	return true;
	}
	// 对单向循环链表的头结点的地址进行备份
	CircLList_t *Phead = Head;

	//   遍历链表，找到尾结点
	while (Phead->next)
	{
		// 把头结点的直接后继作为新的头结点
		Phead = Phead->next;

		// 判断是否到达尾结点，尾结点的next指针是指向首结点的地址
		if (Phead->next == Head->next)
		{
			break;
		}
	}


	// 将尾结点的指针域指向首结点的直接后继、
	Phead->next = temp->next;

	// 将头结点的指针域指向首结点的直接后继
	Phead->next = temp->next;

	// 删除并释放首结点
	Head->next = NULL;
	free(temp);

	return true;
}

/******************************************************
 *
 *  name      : CircLList_HailDel
 *	function  : 删除链表的尾结点
 *  argument
 * 				@head : 头结点的地址
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 尾删
bool CircLList_HailDel(CircLList_t *Head)
{
	// 判断链表是否为空
	if (Head == Head->next)
	{
		printf("链表为空\n");
		return false;
	}

	// 对首结点做备份
	CircLList_t *Phead = Head->next;
	// 对头结点做备份
	CircLList_t *pre_Phead = Head;

	// 处理链表只有一个结点的情况
	if (Phead->next = Phead)
	{
		Phead->next = NULL;
		free(Phead);
		Head->next = NULL;
		return true;
	}

	//  遍历链表，找到尾结点和尾结点的直接前驱
	while (Phead->next)
	{
		// 把头结点的直接后继作为新的头结点
		Phead = Phead->next;
		pre_Phead = pre_Phead->next;

		// 判断是否到达尾结点，尾结点的next指针是指向首结点的地址
		if (Phead->next == Head->next)
		{
			break;
		}
	}

	// 将尾结点的直接前驱的指针域指向首结点
	pre_Phead->next = Head->next;

	// 删除并释放尾结点
	Phead->next = NULL;
	free(Phead);

	return true;
}

/******************************************************
 *
 *  name      : CircLList_DestNode
 *	function  : 将链表的指定结点删除
 *  argument
 * 				@head : 头结点的地址
 * 				@destval : 需要插入位置的结点的数据域
 *
 *  retval    : 成功为1，否则为0
 *  author    : Dazz
 *  date      : 2024/4/23
 *  note      : None
 *
 * *******************************************************/
// 指定删
bool CircLList_DestNode(CircLList_t *Head, DataType_t destval)
{
	// 判断链表是否为空
	if (Head == Head->next)
	{
		printf("链表为空\n");
		return false;
	}

	// 对首结点做备份
	CircLList_t *phead = Head;

	//  遍历链表，找到目标结点
	while (phead != NULL && destval != phead->data)
	{
		phead = phead->next;
	}

	if (NULL == phead)
	{
		printf("找不到需要插入的目标结点\n");
		return false;
	}

	// 对头结点做备份
	CircLList_t *pre_Phead = Head;
	//  遍历链表，找到目标结点的直接前驱
	while (phead == pre_Phead->next)
	{
		pre_Phead = pre_Phead->next;
	}

	// 将待删除结点的直接前驱的指针域指向待删除结点的直接后继
	pre_Phead->next = phead->next;

	// 删除并释放待删除结点
	phead->next = NULL;
	free(phead);

	return true;
}

int main(int argc, char const *argv[])
{

	return 0;
}