基于C语言-循环链表-增删查改等功能实现

** Ghost **

已于 2022-12-14 20:04:07 修改

阅读量222

点赞数

文章标签：链表 c语言数据结构开发语言

于 2022-12-14 19:52:29 首次发布

本文链接：https://blog.csdn.net/m0_51480797/article/details/128320987

版权

链表的结构上还是双链表结构，需要将其初始化为循环状态。

1. 创建结构体

typedef struct DoubleLinkNode 
{
	/*
		双链表
		DoubleLinkNode	表示双链表单个结点
	*/
	ElemType data;
	struct DoubleLinkNode *prior, *next;
}DoubleLinkNode;

2. 创建双链表结点

DoubleLinkNode *createDoubleLinkListNode(ElemType element)
{
	/*
		新增一个双链表结点
	*/
	DoubleLinkNode *newNode = (DoubleLinkNode *)malloc(sizeof(DoubleLinkNode));
	if (newNode == NULL)
	{
		printf("申请空间失败!!!\n");
	}else{
		newNode->data = element;
		newNode->next = NULL;
		newNode->prior = NULL;
        return newNode;
	}
}

3. 初始化链表

DoubleLinkNode *ListInit_Circular()
{
	/*
		循环链表初始化
	*/
	DoubleLinkNode *phead = createDoubleLinkListNode(0);
	phead->next = phead;
	phead->prior = phead;

	return phead;
}

4. 打印循环链表

void CircularLinkListPrint(DoubleLinkNode *List)
{
	/*
		循环链表打印
	*/
	//只有一个结点
	if (List->next == List && List->prior == List)
	{
		printf(" %d ", List->data);
	}
	//两个及以上结点
	else{
		DoubleLinkNode *cur = List->next;
		while(cur != List)
		{
			printf("%d ", cur->data);
			cur = cur->next;
		}
	}
	printf("   This is circular link list. \n");
}

5. 循环链表的尾插元素

void CircularLinkListPushBack(DoubleLinkNode *List, ElemType element)
{
	/*
		循环链表的尾插
		备注：因为有初始化函数，所以不考虑空表的情况
	*/

	DoubleLinkNode *newNode = createDoubleLinkListNode(element);
	DoubleLinkNode *tail = List->prior;

	tail->next = newNode;
	newNode->prior = tail;

	newNode->next = List;
	List->prior = newNode;
}

6. 循环链表的尾删元素

void CircularLinkListPopBack(DoubleLinkNode *List)
{
	/*
		循环链表的尾删
	*/
	DoubleLinkNode *tail = List->prior;	//尾结点
	DoubleLinkNode *tailPre = tail->prior;	//尾结点上一个结点

	tailPre->next = List;
	List->prior = tailPre;

	free(tail);
	tail = NULL;
}

7. 循环链表的头插元素

void CircularLinkListPushFront(DoubleLinkNode *List, ElemType element)
{
	/*
		循环链表头插
	*/
	DoubleLinkNode *newNode = createDoubleLinkListNode(element);
	DoubleLinkNode *first = List->next;

	List->next = newNode;
	newNode->prior = List;

	newNode->next = first;
	first->prior = newNode;
}

8. 循环链表的头删元素

void CircularLinkListPopFront(DoubleLinkNode *List)
{
	/*
		循环链表头删
	*/
	DoubleLinkNode *first = List->next;
	DoubleLinkNode *first_next = first->next;

	List->next = first_next;
	first_next->prior = List;

	free(first);
	first = NULL;
}

9. 查找元素的位置

DoubleLinkNode *CircularListSearch(DoubleLinkNode *List, ElemType element)
{
	/*
		找到元素element的位置
	*/

	DoubleLinkNode *cur = List->next;
	while (cur != List)
	{
		if (cur->data == element)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

10. 循环链表指定位置插入元素

enum Option
{
	/*
		循环链表指定位置插入和删除中使用
	*/
	prior = 1,
	current,
	next

};

void CircularLinkListInsert(DoubleLinkNode *List, int position, ElemType element, short oneORzero)
{
	/*
		循环链表指定位置（position）插入元素（element）
	*/

	DoubleLinkNode *newNode = createDoubleLinkListNode(element);
	DoubleLinkNode *first = List->next;
	int num = 1;
	while(num != position)
	{
		num++;
		first = first->next;
	}
	if (oneORzero == next)
	{
		//在选定位置右边插入
		DoubleLinkNode *firstPre = first->next;
		first->next = newNode;
		firstPre->prior = newNode;
		newNode->prior = first;
		newNode->next = firstPre;
	} else{
		//在选定位置左边插入
		DoubleLinkNode *firstPrior = first->prior;
		firstPrior->next = newNode;
		first->prior = newNode;
		newNode->next = first;
		newNode->prior = firstPrior;
	}

}

11. 循环链表指定位置删除元素

enum的结构请查看上一条（10.）

void CircularLinkListDelete(DoubleLinkNode *List, int position, short priorORcurrentORnext)
{
	/*
		循环链表删除指定位置的元素
		备注：
			可选择删除选择位置的元素或者--current
			选择位置下一个元素或者--next
			选择位置上一个元素--prior
	*/
	DoubleLinkNode *first = List->next;
	int num = 1;
	while(num != position)
	{
		num++;
		first = first->next;
	}
	if (priorORcurrentORnext == prior)
	{
		//删除选择位置上一个结点
		DoubleLinkNode *firstPre = first->prior;			//选择位置上一个结点
		DoubleLinkNode *firstPre_Pre = firstPre->prior;		//选择位置上上一个结点

		firstPre_Pre->next = first;
		first->prior = firstPre_Pre;

		free(firstPre);		//删除选择位置的上一个结点
		firstPre = NULL;
	}
	else if (priorORcurrentORnext == next)
	{
		//删除选择位置下一个结点
		DoubleLinkNode *firstNext = first->next;			//选择位置下一个结点
		DoubleLinkNode *firstNext_Next = firstNext->next;	//选择位置下下一个结点

		first->next = firstNext_Next;
		firstNext_Next->prior = first;

		free(firstNext);	//删除选择位置的下一个结点
		firstNext = NULL;
	}else{
		//删除选择位置的结点
		DoubleLinkNode *firstPre = first->prior;
		DoubleLinkNode *firstNext = first->next;

		firstPre->next = firstNext;
		firstNext->prior = firstPre;

		free(first);
		first = NULL;
	}

}

12. 销毁当前的链表

void ListDestory(DoubleLinkNode *List)
{
	/*
		销毁当前的链表
	*/
	DoubleLinkNode *cur = List->next;
	while (cur != List)
	{
		DoubleLinkNode *next = cur->next;
		free(cur);
		cur = next;
	}
	free(cur);
	cur = NULL;
}

13. 清空链表

void ListClear(DoubleLinkNode *List)
{
	/*
		清空当前的链表（只保留头结点）
	*/
	DoubleLinkNode *cur = List->next;
	while (cur != List)
	{
		DoubleLinkNode *next = cur->next;
		free(cur);
		cur = next;
	}
	List->next = List;
	List->prior = List;
}