详解循环链表

已于 2023-10-15 12:17:11 修改
阅读量1.4k 收藏
点赞数
文章标签： 链表 数据结构
于 2023-10-14 22:40:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/D3540987120/article/details/133832602
版权

一、基本概念

循环链表是一种特殊的链表，它的最后一个节点的next指针指向链表的头节点，形成一个环形结构。

二、定义

循环链表由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。最后一个节点的指针指向链表的头节点，形成一个环形结构。

优点：
链表是一种动态排列，可以通过分配和刷新内存在运行时增长和收缩。对于链表，无论是单链表、双链表还是循环链表，都不需要知道元素和分配内存，因为它可以在必要时分配。
可以有效地处理循环链表的插入和删除，而无需重新构造链表。插入或删除元素后无需移动元素，只需更新下一个指针中存在的地址。

缺点：

循环链表的操作相对复杂，需要特别处理循环结束条件和遍历。
需要注意循环链表的特殊性，避免出现无限循环的情况。

三、代码实现

1.接口定义

/*
	LinkList.h
*/

typedef int DataType;

/*链表的定义*/
typedef struct node
{
	DataType		data;	/*数据域*/
	struct node		*next;	/*指针域*/
}LinkList, LinkNode;


/*1. 初始化*/
int initList(LinkList **Head);

/*2. 插入元素,头插法*/
int insert_head(LinkList **Head, DataType x);

/*2. 插入元素， 尾插法*/
int insert_tail(LinkList **Head, DataType x);

/*2. 插入元素，在位置i处插入元素x */
int insertData(LinkList **Head, int i, DataType x);

/*3. 删除元素, 删除值为x的元素*/
int deleteData(LinkList **Head, DataType x);

/*5. 查找值为x的元素，返回位置i */
int findData(LinkList *Head, DataType x);

/*6. 求链表的长度 */
int length(LinkList *Head);

/*7.输出链表*/
void printList(LinkList *Head);

2.接口实现

2.1  循环链表初始化
/*1. 链表初始化*/
int initList(LinkList **Head)
{
	if(1)
	{
		/*申请内存*/
		(*Head) = (LinkList*)malloc(sizeof(LinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
            printf("申请内存错误，初始化失败！[100001]\n");
			return 100001;
		}
		(*Head)->next = *Head;
	
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}
2.2 链表插入 （头插法、尾插法、按位插入）
/*2. 头插法*/
int insert_head(LinkList **Head, DataType x)
{
	LinkNode *newNode;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (LinkNode*)malloc(sizeof(LinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}


/*2. 尾插法*/
int insert_tail(LinkList **Head, DataType x)
{
	LinkNode *newNode;
	LinkNode *p;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (LinkNode*)malloc(sizeof(LinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}

	newNode->data = x;
	newNode->next = *Head;

	p = (*Head);

	while(p->next != *Head )
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}


/*2. 按位插入 */
//在位置i处插入元素x
int insertData(LinkList **Head, int i, DataType x)
{
	int j;
	LinkNode *p;
	LinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	if(i<1 || i>length(*Head)+1)
	{
		printf("位置i不是链表有效位置！[100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;

	while(j<i)
	{
		j++;
		p = p->next;
	}

	newNode = (LinkNode*)malloc(sizeof(LinkNode));
	/*此处省略检测newNode是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}
2.3 按值删除
/*3. 按值删除*/
// 删除值为x的元素
int deleteData(LinkList **Head, DataType x)
{
	int i;
	int j;

	LinkNode *p;
	LinkNode *q; /*要删除的元素x*/

	i = findData(*Head,x);
	if(!i)
	{
		printf("元素x【%d】不存在！100006\n", x);
		return 100006;
	}
	
	p = (*Head);
	j=1;

	while(j<i)
	{
		j++;
		p = p->next;
	}
	
	q = p->next;
	p->next = q->next;

	free(q); /*释放内存*/

	return 0;
}
2.4 按值查找元素
/*5. 查找值为x的元素，返回位置i */
int findData(LinkList *Head, DataType x)
{
	int i;
	LinkNode *p;

	i = 1;
	p = Head->next;

	while(p!=Head && p->data != x) 
	{
		i++;
		p = p->next;
	}

	if(p->next == Head) 
	{
		return 0;
	}
	else
	{
		return i;
	}

}
2.5 链表长度
/*4. 链表长度*/
int length(LinkList *Head)
{
	int len=0;
	LinkNode *p;

	p = Head->next;
	while(p!=Head)
	{
		len++;
		p = p->next;
	}
	return len;
}
2.6 输出链表
/*6.输出链表*/
void printList(LinkList *Head)
{
	LinkNode *p;
	int i=0;

	p = Head->next;
	if(p == Head)				
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}
2.7 main方法
#include <stdio.h>
#include <string.h>
#include "LinkList.h"
// #include "welcome.h"


char welcome[] = "\n//                          _ooOoo_                               //\n//                         o8888888o                              //\n//                         88”.“88                              //\n//                         (| ^_^ |)                              //\n//                          O\  =  /O                              //\n//                       ____/`---'\____                           //\n//                     .'  \\|     |//  `.                         //\n//                     /  \\|||  :  |||//  \                        //\n//                   /  _||||| -:- |||||-  \                       //\n//                    |   | \\\  -  /// |   |                       //\n//                    | \_|  ''\---/''  |   |                       //\n//                    \  .-\__  `-`  ___/-. /                       //\n//                 ___`. .'  /--.--\  `. . ___                     //\n//          .‘’ '<  `.___\_<|>_/___.'  >' ‘’.                  //\n//              | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //\n//                \  \ `-.   \_ __\ /__ _/   .-` /  /                 //\n//       ========`-.____`-.___\_____/___.-`____.-'========         //\n//                           `=---='                              //\n//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //\n//           佛祖保佑      永不宕机     永无BUG                   //\n\n";



int main(int argc, char* argv[])
{
	LinkList *Head;
	DataType x;
	int i, m,n,cmd;

    	for(int i=0;i<strlen(welcome);i++)
	    {
		    printf("%c",welcome[i]);
		    for(int m=0;m<10000;m++)
			    for(int n=0;n<300;n++)
			    {
				    
			    }
	    }

	printf("-----------循环链表演示程序----------\n");
	do
	{
		printf("1. 初始化循环链表\n");
		printf("2. 插入元素（头插法）\n");
		printf("3. 插入元素（尾插法）\n");
		printf("4. 在位置i插入元素\n");
		printf("5. 查找元素\n");
		printf("6. 输出链表长度\n");
		printf("7. 输出链表\n");
		printf("8. 删除元素\n");
		printf("10. 帮助\n"); 
		printf("0. 退出\n");
		printf("请输入您要进行的操作（1~6,0退出）：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			if(!initList(&Head))
			{
				printf("链表已初始化！\n");
			}
			break;
		case 2:
			printf("请输入插入元素x：x=");
			scanf("%d",&x);
			if(!insert_head(&Head,x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 3:
			printf("请输入插入元素x：x=");
			scanf("%d",&x);
			if(!insert_tail(&Head,x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 4:
			printf("请输入插入元素位置：");
            scanf("%d",&i);
            printf("请输入要插入的元素：");
			scanf("%d",&x);
			if(!insertData(&Head, i, x))
			{
				printf("已在位置（%d）插入元素（%d）！\n",i, x);
			}
			break;
		case 5:
			printf("请输入要查找的元素x：");
			scanf("%d", &x);
			if(i = findData(Head,x))
			{
				printf("元素%d存在，在链表位置%d.\n", x, i);
			}
			else
			{
				printf("在链表中未找到元素x。\n");
			}
			break;
		case 6:
			printf("链表的长度为：%d\n", length(Head));
			break;
		case 7:
			printList(Head);
			break;
		case 8:
			printf("请输入要删除的元素x：");
			scanf("%d", &x);
			if(!deleteData(&Head, x))
			{
				printf("元素x【%d】已删除!\n", x);
			}
			break;
		case 10:
			printf(" 本程序为链表的演示程序，由杜露设计开发，本程序演示了循环链表功能！\n");
			break;
			
		}
	}while(cmd != 0);

	return 0;
}

3.程序演示

四、扩展练习

一元多项式相加

#include <stdio.h>
#include <stdlib.h>


char welcome[] = "\n//                          _ooOoo_                               //\n//                         o8888888o                              //\n//                         88”.“88                              //\n//                         (| ^_^ |)                              //\n//                          O\  =  /O                              //\n//                       ____/`---'\____                           //\n//                     .'  \\|     |//  `.                         //\n//                     /  \\|||  :  |||//  \                        //\n//                   /  _||||| -:- |||||-  \                       //\n//                    |   | \\\  -  /// |   |                       //\n//                    | \_|  ''\---/''  |   |                       //\n//                    \  .-\__  `-`  ___/-. /                       //\n//                 ___`. .'  /--.--\  `. . ___                     //\n//          .‘’ '<  `.___\_<|>_/___.'  >' ‘’.                  //\n//              | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //\n//                \  \ `-.   \_ __\ /__ _/   .-` /  /                 //\n//       ========`-.____`-.___\_____/___.-`____.-'========         //\n//                           `=---='                              //\n//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //\n//           佛祖保佑      永不宕机     永无BUG                   //\n\n";

// 定义循环单链表节点结构
typedef struct Node {
    int c; // 系数
    int e; // 指数
    struct Node *next; // 指向下一个节点的指针
} Node;

// 定义循环单链表结构
typedef struct LinkedList {
    Node *head; // 头节点
} LinkedList;

// 初始化循环单链表
void initLinkedList(LinkedList *list) {
    //初始化先指向空,存储节点后再指向head构成循环链表结构
    list->head = NULL;
}

// 在循环单链表尾部插入一个节点
int insertNode(LinkedList *list, int c, int e) {
    //申请内存
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->c = c;
    newNode->e = e;
    newNode->next = NULL;

    if (list->head == NULL) {
        list->head = newNode;

        // 将尾节点的next指针指向头节点，构成循环链表
        newNode->next = newNode; 
    } else {
        Node *temp = list->head;
        while (temp->next != list->head) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->next = list->head;
    }

    return 0;
}

// 打印循环单链表
int printLinkedList(LinkedList *list) {
    if (list->head == NULL) {
        printf("这链表是空的！[10001]\n");
        return 10001;
    }

    Node *temp = list->head;
    do {
        //打印系数不为零的项
        if (temp->c != 0)
        {
           printf("%dx^%d, ", temp->c, temp->e);
        }
        
        
        temp = temp->next;
    } while (temp != list->head);
    printf("\n");

    return 0;
}

// 一元多项式相加
LinkedList add(LinkedList *poly1, LinkedList *poly2) {
    //创建新的链表，用来存储相加后的结果
    LinkedList result;
    //初始化链表
    initLinkedList(&result);

    Node *temp1 = poly1->head;
    Node *temp2 = poly2->head;

    do {
        //判断系数是否相等，如果相等就将相同系数项相加
        if (temp1->e == temp2->e) {
            int sum = temp1->c + temp2->c;
            if (sum != 0) {
                insertNode(&result, sum, temp1->e);
            }
            temp1 = temp1->next;
            temp2 = temp2->next;
        } else if (temp1->e > temp2->e) {//系数不同，直接插入
            insertNode(&result, temp1->c, temp1->e);
            temp1 = temp1->next;
        } else{
            insertNode(&result, temp2->c, temp2->e);
            temp2 = temp2->next;
        }
    } while (temp1 != poly1->head && temp2 != poly2->head);


    //将两个多项式节点插入到新的链表中
    while (temp1 != poly1->head) {
        insertNode(&result, temp1->c, temp1->e);
        temp1 = temp1->next;
    }

    while (temp2 != poly2->head) {
        insertNode(&result, temp2->c, temp2->e);
        temp2 = temp2->next;
    }

    //返回结果
    return result;
}

int main() {
    LinkedList poly1, poly2, result;
    initLinkedList(&poly1);
    initLinkedList(&poly2);

    int c, e,i,num1, num2;


    	for(int i=0;i<strlen(welcome);i++)
	    {
		    printf("%c",welcome[i]);
		    for(int m=0;m<10000;m++)
			    for(int n=0;n<300;n++)
			    {
				    
			    }
	    }



    while (i != 1)
    {
        printf("--------------------------------\n");
        printf("一元多项式\n程序演示[0]:\n");
        printf("退出：[1]\n");
        scanf("%d",&i);

        printf("请输入第一个多项式的项数: ");
        scanf("%d", &num1);

        printf("请输入多项式中每个项的系数和指数(空格隔开):\n");
        for (int i = 0; i < num1; i++) {
            scanf("%d %d", &c, &e);
            insertNode(&poly1, c, e);
        }

        printf("请输入第二个多项式的项数: ");
        scanf("%d", &num2);

        printf("请输入多项式中每个项的系数和指数(空格隔开):\n");
        for (int i = 0; i < num2; i++) {
            scanf("%d %d", &c, &e);
            insertNode(&poly2, c, e);
        }

        printf("第一个多项式: ");
        printLinkedList(&poly1);

        printf("第二个多项式: ");
        printLinkedList(&poly2);

        result = add(&poly1, &poly2);

        printf("相加结果: ");
        printLinkedList(&result);

        printf("---------------END-----------------\n");
    }


    return 0;
}

结果演示

五、小结：

循环链表是一种特殊的链表，它的最后一个节点的next指针指向链表的头节点，形成一个环形结构。循环链表在特定问题的实现中具有一定的优势，例如约瑟夫环问题。然而，循环链表的操作相对复杂，需要特别处理循环结束条件和遍历。在使用循环链表时，需要注意循环链表的特殊性，避免出现无限循环的情况。

参考文献

优快云、数据结构（C语言版）

Q3540987120
关注
详解循环链表（数据结构C语言）
m0_59068067的博客
10-15 1386
本文简单介绍了循环链表的基本概念，特点以及基础运算，并附上了代码以及结果，希望以后复习时可以加深自己的印象；在运行过程中，总有一些卡壳的部分，在朋友的指导下，修改代码并顺利完成结果。
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5494
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
循环链表范例（约瑟夫问题）指针实现
MACHINE_128的博客
02-03 365
#include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #include&lt;math.h&gt; typedef struct node* link;  //链接 struct node { int item; link next;   };//节点 int main(void) { int N,M; printf("输入人数N\n...
循环char 指针_三、循环链表和双向链表
weixin_39970166的博客
11-23 153
接触过单链表后，我们要引申出循环链表和双向链表，他们比单链表结构更复杂，但是效率更高。1. 循环链表循环链表的定义很简单，即在单链表基础上，尾结点的next指针指向第一个结点（注意：不是头结点），这样整个链表就循环了。因为循环，我们可以从任何一个结点遍历到所需结点。我们照样看下插入、删除算法，这次我们还将加一个遍历算法。首先是插入，循环链表的几点插入和单链表的插入唯一不同的地方在于：如果插入的是尾...
深入理解链表中的 p = p-＞next；操作
最新发布
Yhame的博客
03-24 464
p是一个指针变量，存储的是节点的地址。p->next也是一个地址，指向下一个节点。只是让p存储新的地址，从而指向下一个节点。这一操作不会改变链表的结构，只是遍历链表时移动指针。可以类比为“换座位”来理解。希望这篇文章能帮你彻底搞懂的执行逻辑！如果你有任何疑问，欢迎在评论区留言讨论。
单个指针下循环链表的入队与出队
makerjack001的博客
10-27 4013
循环链表的入队出队 题目是这样的： 设以不带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，但不设头指针。编写相应的入队和出队程序。 如果带头尾指针那就很简单了，不带头尾指针只能在函数中新建工作指针来操作。 思考方向 队列嘛，先进先出，用循环链表存储，再有个尾指针，逻辑结构就是这样的 入队 入队分三步： 新结点指向头结点 尾结点指向新节点 尾指针指向新的尾结点 出队 先进先出嘛，头结点删了就行 理论上直接尾结点指向第二个就完事了 但这样只是找不到了原来的头结点，它依然是存在于内存中的，虽说眼不见为
数据结构笔记——链表
关于我的学习记录
12-05 2424
数据结构笔记——链表
数据结构—链表
小芦荟同学的博客
08-06 1145
链表 目录 一、概述 二、单链表 三、双链表 四、双指针 五、经典问题—反转链表 一、概述 1.链表是什么 2.链表的基本结构 3.链表的分类 4.链表和数组的比较 5.设计链表：源代码（含测试用例） 1.链表是什么 链表数一种线性数据结构。它是动态地进行储存分配的一种结构。 什么是线性结构，什么是非线性结构？ 线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。 非线性结构，是一个结点元素可能有多个直接前趋和多个直接后继。常见的非线性结构有：二维数组，多维数组，广义表，
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
【数据结构与算法】- (带尾指针)单循环链表 - 详细实现步骤及代码(C/C++)
wkd_007的博客
03-30 9837
本文主要介绍带尾指针的单循环链表，以及详细的实现步骤讲解，最后提供一份自己实现带尾指针的单循环链表的C语言代码
关于带有尾指针的循环链表的知识点
cheng_zi_lai_le的博客
01-10 1676
带有尾指针的循环链表的创建头结点 插入结点 头插法插入结点 尾插法插入节点 或许链表结点数量
算法——链表
裙下的霸气的博客
12-25 1161
我们一般选择创建哨兵位头结点，这里我们哨兵位不存储数据。解释传入空链表，这里的newhead只需要特判一下即可不要吝啬空间，大胆定义变量。
数据结构 - 循环链表
weixin_52952392的博客
10-15 1084
一. 循环链表的概念循环链表（Circular Linked List）是一种链表数据结构，它与普通链表（单链表或双链表）不同的地方在于，循环链表的最后一个节点指向第一个节点，形成一个闭合的环。在一个标准的单向循环链表中，最后一个节点的指针域将指向第一个节点，而在双向循环链表中，除了有指向下一个节点的指针外，还有指向前一个节点的指针。这种闭合的环形结构允许你从任何节点出发遍历整个链表，而不必担心链表的结束。
数据结构学习(一)
IOSSHAN的博客
09-08 2975
文章采取What、Why、How、Attention分析写 链表的定义： 链表是一个离散存储的，每一个结点只有一个前驱结点和一个后继结点，且第一个结点没有前驱结点，最后一个结点没有后继结点。 首结点、尾结点、头结点、头指针、尾指针： 首结点指的是第一个有效结点； 尾结点指的是最后一个有效结点； 头结点指的是首结点前面的结点，头结点并不存放有效数据，该结点的存在是为了对链表更好的操作； 头指针指的是...
循环单链表
Forrit的博客
11-28 3405
以带头结点的循环单链表为例： 普通的单链表的尾指针指向的是NULL; 而循环单链表的尾指针指向的是头节点； 这就要求循环单链表在定义的时候出现的一些不同： 初始化时，需要将头结点的next指针指向它自己 判空条件，L->next==L; 判断p是否为尾节点的条件：p->next==L ...
数据结构循环链表
mr_yuyou的博客
07-10 433
循环链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值