数据结构-链表-循环链表

已于 2023-10-15 23:24:33 修改
阅读量192 收藏
点赞数
文章标签： 数据结构 链表
于 2023-10-15 13:12:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Arrebol_c1023/article/details/133841185
版权

          链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表的最后一个节点指向空值，表示链表的结束。

         循环链表是一种特殊的链表，它的最后一个节点不是指向空值，而是指向链表的头节点，形成一个闭环。换句话说，循环链表的头节点的前驱节点是尾节点，尾节点的后继节点是头节点。循环链表可以通过在链表的末尾将尾节点的指针指向头节点来创建。这样一来，可以通过尾节点的指针遍历整个链表，而不需要额外的指针变量。循环链表的优点是可以很方便地实现环形结构，比如循环队列和循环缓冲区。此外，循环链表也可以解决一些特殊的问题，比如约瑟夫环问题。需要注意的是，在处理循环链表时，需要特别注意循环的终止条件，以免陷入死循环。同时，插入、删除节点等操作也需要考虑循环链表的特殊性，确保链表仍然保持循环结构。

        总之，循环链表是一种特殊的链表，具有闭环的特点。它可以方便地实现环形结构，并解决一些特殊的问题。在处理循环链表时，需要注意循环的终止条件和操作的特殊性。

单链表

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

struct Node {
    int data;
    struct Node* next;
};

void insert(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;

    if (*head == NULL) {
        *head = newNode;
    } else {
        struct Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

void display(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

void delete(struct Node** head, int data) {
    if (*head == NULL) {
        return;
    }

    struct Node* current = *head;
    if (current->data == data) {
        *head = current->next;
        free(current);
        return;
    }

    struct Node* prev = NULL;
    while (current != NULL && current->data != data) {
        prev = current;
        current = current->next;
    }

    if (current == NULL) {
        return;
    }

    prev->next = current->next;
    free(current);
}

int main() {
    struct Node* head = NULL;

    insert(&head, 1); // 插入节点 1
    insert(&head, 2); // 插入节点 2
    insert(&head, 3); // 插入节点 3
    insert(&head, 4); // 插入节点 4
    insert(&head, 5); // 插入节点 5

    printf("Original List: ");
    display(head);

    delete(&head, 3); // 删除节点 3

    printf("List after deleting 3: ");
    display(head);

    return 0;
}

循环链表

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

struct Node {
    int data;
    struct Node* next;
};

void insert(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;

    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
    } else {
        struct Node* current = *head;
        while (current->next != *head) {
            current = current->next;
        }
        current->next = newNode;
        newNode->next = *head;
    }
}

void display(struct Node* head) {
    struct Node* current = head;
    do {
        printf("%d ", current->data);
        current = current->next;
    } while (current != head);
    printf("\n");
}

void delete(struct Node** head, int data) {
    if (*head == NULL) {
        return;
    }

    struct Node* current = *head;
    struct Node* prev = NULL;
    while (current->next != *head) {
        if (current->data == data) {
            if (prev == NULL) {
                struct Node* last = *head;
                while (last->next != *head) {
                    last = last->next;
                }
                *head = current->next;
                last->next = *head;
                free(current);
                return;
            } else {
                prev->next = current->next;
                free(current);
                return;
            }
        }
        prev = current;
        current = current->next;
    }

    if (current->data == data) {
        if (prev == NULL) {
            *head = NULL;
            free(current);
            return;
        } else {
            prev->next = *head;
            free(current);
            return;
        }
    }
}

int main() {
    struct Node* head = NULL;

    insert(&head, 1); // 插入节点 1
    insert(&head, 2); // 插入节点 2
    insert(&head, 3); // 插入节点 3
    insert(&head, 4); // 插入节点 4
    insert(&head, 5); // 插入节点 5

    printf("Original List: ");
    display(head);

    delete(&head, 3); // 删除节点 3

    printf("List after deleting 3: ");
    display(head);

    return 0;
}

单向链表和循环链表的主要区别在于插入和删除节点时对尾节点指针的处理。

        对于链表，插入和删除节点时，需要考虑头节点和尾节点的特殊情况。在插入节点时，如果在头部插入，只需要将新节点的next指针指向原来的头节点，然后更新头节点为新节点。在尾部插入时，需要遍历链表找到最后一个节点，然后将最后一个节点的next指针指向新节点。在删除节点时，如果删除头节点，只需要将头节点更新为下一个节点。对于其他位置的节点，需要遍历链表找到要删除的节点的前一个节点，然后将前一个节点的next指针指向要删除节点的下一个节点。

        而对于循环链表，插入和删除节点时需要特别处理尾节点的指针。在插入节点时，如果在头部插入，需要将新节点的next指针指向原来的头节点，然后更新尾节点的next指针指向新节点，最后更新头节点为新节点。在尾部插入时，需要遍历链表找到尾节点，然后将尾节点的next指针指向新节点，新节点的next指针指向头节点。在删除节点时，如果删除头节点，需要更新尾节点的next指针指向头节点的下一个节点，然后更新头节点为下一个节点。对于其他位置的节点，需要遍历链表找到要删除的节点的前一个节点，然后将前一个节点的next指针指向要删除节点的下一个节点。

除了插入和删除节点时对尾节点指针的处理外，链表和循环链表的基本操作是相似的。都包括在末尾插入节点、在头部插入节点、在指定位置插入节点、删除指定位置的节点和遍历链表。

Demo

#include <stdio.h>
#include <string.h> 
#include "SingleLinkList.h" // 引入单链表头文件
#include "welcome.h" // 引入欢迎信息头文件

int main(int argc, char* argv[]) // 主函数
{     SingleLinkList *Head; // 定义单链表头指针 
      DataType x; // 定义数据类型变量
      x int i,m,n,cmd; // 定义循环计数器和命令选项



	for(i=0;i<strlen(welcome);i++) // 输出欢迎信息
{
	printf("%c",welcome[i]);
	for(m=0;m<1000;m++) // 延时
		for(n=0;n<1000;n++)
		{
			;
		}
}

printf("-----------简单链表演示程序----------\n"); // 输出菜单
do
{
	printf("1. 初始化链表表\n");
	printf("2. 插入元素（头插法）\n");
	printf("3. 插入元素（尾插法）\n");
	printf("4. 插入元素（在位置i插入）\n");
	printf("5. 查找元素x\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(!init(&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("请输入插入元素位置i和元素x（i，x）：");
		scanf("%d,%d", &i, &x);
		if(!insert(&Head, i, x)) // 在位置i插入元素
		{
			printf("已在位置（%d）插入元素（%d）！\n",i, x);
		}
		break;
	case 5:
		printf("请输入要查找的元素x：");
		scanf("%d", &x);
		if(i = find(Head,x)) // 查找元素x
		{
			printf("元素%d存在，在链表位置%d.\n", x, i);
		}
		else
		{
			printf("在链表中未找到元素x。\n");
		}
		break;
	case 6:
		printf("链表的长度为：%d\n", length(Head)); // 求链表长度
		break;
	case 7:
		print(Head); // 输出链表
		break;
	case 8:
		printf("请输入要删除的元素x：");
		scanf("%d", &x);
		if(!delete(&Head, x)) // 删除元素x
		{
			printf("元素x【%d】已删除!\n", x);
		}
		break;
	case 10:
		printf(" 本程序为链表的演示程序，有设计开发，程序完成了环形链表功能！\n");
		break;
		
	}
}while(cmd != 0);

return 0;

Demo running result

-----------简单链表演示程序----------
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：1
链表已初始化！
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：2
请输入插入元素x：x=3
元素（3）已插入
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：3
请输入插入元素x：x=5
元素（5）已插入
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：3
请输入插入元素x：x=7
元素（7）已插入
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：4
请输入插入元素位置i和元素x（i，x）：3,5
已在位置（3）插入元素（5）！
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：5
请输入要查找的元素x：5
元素5存在，在链表位置3.
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：6
链表的长度为：4
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：7
Node[1]. = 3
Node[2]. = 3
Node[3]. = 5
Node[4]. = 5
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出
请输入您要进行的操作（1~6,0退出）：8
请输入要删除的元素x：3
元素x【3】已删除!
1. 初始化链表表
2. 插入元素（头插法）
3. 插入元素（尾插法）
4. 插入元素（在位置i插入）
5. 查找元素x
6. 求链表长度
7. 输出链表
8. 删除元素
10. 帮助
0. 退出

内容小结

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

  2. 循环链表可以通过头指针来访问整个链表，而不需要遍历整个链表。

  3. 循环链表的操作和单链表类似，包括初始化链表、插入元素、删除元素、查找元素等操作。

  4. 循环链表可以简化一些操作，例如遍历整个链表时不需要判断是否到达链表末尾，而是通过判断指针是否指向头节点来结束遍历。

  5. 循环链表可以用于实现队列、栈等数据结构，也可以用于解决一些特殊的问题，例如约瑟夫环问题等。

  6. 在实现循环链表时，需要注意插入和删除元素时尾节点的指针指向。

  7. 循环链表在内存分配和释放上相对于单链表更加复杂，需要注意避免内存泄漏和野指针的问题。

Arrebol_c1023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构链表之单循环链表
u010814426的专栏
07-27 696
在这里，也设置一个头指针。 对于有着头指针的单循环链表L，判断L为空的条件为L->next == L，这是与单链表与循环链表不一样的地方。 除此之外，链表的最后一个节点指向头结点。 要注意的是，对循环链表进行操作的时候，需要注意链表为空的情况。 常用操作的代码为： //循环列表 #include #include struct List{ int val; List *next;
c语言_数据结构_双向循环链表
SahPah的专栏
08-13 1977
双向循环链表与单向循环链表的区别在于，每个节点的指针域中除了有指向下一结点的next指针外，还有指向前一结点的prev指针：   在链表中，中间部分结点的next指针指向其直接后继结点，prev指针指向其直接前继结点。与单向循环链表相同，末结点的next指针不再指向NULL,而是指向头结点Head，而头结点的prev则指向末结点。 将新结点new插入到p所指向的结点之后：
leetcode24 两两交换链表中的节点
qq_41295976的博客
03-18 54
思路： 先，对于这种在原链表操作链表的题目，要考虑是否通过添加一个临时的头节点，使后续操作一般化。 对于本题来说，由于两两交换，头节点要和后一节点也交换，而仅有头节点，操作不方便，且与后续操作有差别，故考虑需要引入临时头节点。 此外，两两交换并没有很复杂，关键是要注意逻辑不能乱，不清楚时可以在纸上画画交换过程。 交换的核心代码如下，其中prev指向需要交换的两个节点的前一节点，curr指向要交换的第一个节点。 即1->2->3->...中，如果交换2和3,那么prev指向1，cu
数据结构 - 链表 - 头节点的意义
qazw9600的专栏
08-12 9926
说明 初学数据结构时，对于链表定义一个空数据的头结点表示不理解，不明白其作用，甚至有时为了节省内存空间而去掉该节点，但是头结点是有意义的。 头结点示意图： 缺点 多定义了一个结点，多占用了一个结点的内存。 改善方式：可以采用linux kernel中的list实现方式（结点中只包含结点指针不包含结点数据），减少头节点的内存占用。 优点 单链表或双链表删除或插入节点时，如果没有头结点，处理有两种情况： 操作的对象是第一个结点，相对于其它情况，需要额外更改链表入口指针。 操作的对象不是第一个结
数据结构与算法：双向链表
洒满阳光的午后的博客
11-05 398
与单向链表相比，双向链表拥有两个指针域，一个指向直接前趋，一个指向直接后继。 双向链表的表示 由图： 双向链表的结点也由数据域和指针域组成；结点之间通过指针域相连，Prev指针指向直接前趋，Next指针指向直接后继；头指针指向首元结点；首元结点的Prev指针为空指针，尾结点的Next指针为空指针。 基本操作 插入——在链表开头插入一个结点         —
C++ 循环单链表（带头结点）
qq_43650934的博客
11-18 1639
文章目录总结归纳代码实现 总结归纳 在 InsertPriorNode 函数中（前插操作），存在一处 bug ，如果在头结点前进行插入会出现数据混乱的情况，因为头结点不存在数据。初步估计，可以通过遍历找到头结点的前一个结点（即最后一个结点），再进行插入操作。 在 DeleteNode 函数中（删除指定结点），如果删除的是最后一个结点，则要特殊处理，需要通过遍历找到该结点的前驱结点，再进行删除操作。 循环链表比起单链表，它的优势在于：知道一个结点，就可以知道该结点的前驱结点，以致于所有结点；而单链表必须通过
数据结构 -- 链表详解
m0_73243771的博客
04-27 2124
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
java数据结构-链表详解
m0_63526467的博客
05-04 4077
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
数据结构-链表
一个努力拼搏的人
11-13 1672
这里用typedef重新定义了int类型的名称，方便以后更换类型。这里用typedef重新定义了int类型的名称，方便以后更换类型。{}DL;
数据结构-单向循环链表
没出过地球
06-11 1979
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
C语言数据结构-链表版学生管理系统
10-02
链表有多种类型，如单链表、双向链表和循环链表等。在这个学生管理系统中，我们可能采用了单链表，其中每个节点代表一个学生的信息，包括学号、姓名、成绩等字段。 首先，我们需要创建链表节点的结构体，定义节点...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
【初阶数据结构篇】顺序表的实现（赋源码）
2301_79849925的博客
07-24 1275
顺序表实现方法
2024.7.24 作业
qq_64434282的博客
07-24 2326
【代码】2024.7.24 作业。
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中.zip
07-31
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中
chromedriver-mac-x64_121.0.6167.184.zip
最新发布
07-31
chromedriver-mac-x64_121.0.6167.184.zip
【Java面试+Java技术文章汇总】 涵盖大部分Java程序员所需要掌握的核心知识。.zip
07-31
【Java面试+Java技术文章汇总】 涵盖大部分Java程序员所需要掌握的核心知识。
数据结构-链表按序号查找算法解析
本资源主要涵盖了数据结构中的查找运算，特别是针对链表的按序号查找操作。在数据结构中，查找运算是一项基础且重要的操作，它涉及到如何有效地在数据集合中定位特定的信息。在讲解查找运算之前，我们首先理解数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值