单向链表、单向循环链表的基本操作

最新推荐文章于 2024-08-20 17:02:31 发布
最新推荐文章于 2024-08-20 17:02:31 发布
阅读量449 收藏 4
点赞数 2
分类专栏： 数据结构 文章标签： c语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52545652/article/details/130148520
版权
本文详细介绍了如何在C语言中实现单向链表和单向循环链表的基本操作，包括定义节点结构体、创建节点、头插法、尾插法、遍历、检索指定数据节点、删除节点、任意位置添加和移动节点以及销毁链表的函数。每个操作都针对两种链表类型进行了区分和实现。
摘要由CSDN通过智能技术生成

（1）定义结点的结构体 

（2）创建的节点的函数

（3）头插法

（4）尾插法

（5）遍历单项向(循环)链表

（6）检索指定的数据节点

（7）删除指定的节点数据

（8）任意位置添加

（9）移动指定数据节点

（10）销毁链表

所有函数如下图所示:

 

（1）定义结点的结构体

有一个数据域和一个指针域，分别用来存放节点的数据，以及下一个的节点。单向链表和单向循坏链表的节点结构体式一样。

typedef struct list_link
{
    int data;
    struct list_link *next;

} list_node, *list_link;

 （2）创建的节点的函数

单向链表

list_link Create_List_Node();

list_link Create_List_Node()
{

    list_link node = (list_link)malloc(sizeof(list_node));
    if (node == (list_link)NULL)
    {
        perror("malloc list node ...");
        return (list_link)-1;
    }

    memset(node, 0, sizeof(list_node));

    node->next = NULL;

    return node;
}

单向循环链表

list_link Create_List_Node()
{
    list_link new_node = (list_link) malloc (sizeof(list_node));
    if (node == (list_link)NULL)
    {
        perror("malloc list node ...");
        return (list_link)-1;
    }
    
    // 内存清空
    memset(new_node, 0, sizeof(list_node));

    // 单向循环链表和单向链表的区别
    // 单向循坏链表的next的是指向自己的
    new_node->next = new_node;

    return new_node;
}

（3）头插法

单向链表和单向循环链表的头插法是一样。

int Head_Add_Node(list_link head)
{

    if (head == (list_link)NULL)
    {
        printf("头节点异常！\n");
        return -1;
    }

    // 创建新的节点
    list_link new_node = Create_List_Node();
    if (new_node == (list_link)-1)
    {
        printf("创建新的节点失败！\n");
        return -1;
    }

    // 输入数据
    printf("请输入数据:");
    scanf("%d", &(new_node->data));

    // 头插法
    new_node->next = head->next;
    head->next = new_node;

    return 0;
}

（4）尾插法

单向链表

int Tail_Add_Node(list_link head)
{

    if (head == NULL)
    {
        printf("头结点异常!\n");
        return -1;
    }

    // 获取尾节点
    list_link tmp_node = NULL;
    for (tmp_node = head->next; tmp_node->next != NULL; tmp_node = tmp_node->next);

    // 创建新结点
    list_link new_node = Create_List_Node();
    if (new_node == (list_link)-1)
    {
        printf("创建新节点失败!\n");
        return -1;
    }

    printf("输入数据:");
    scanf("%d", &(new_node->data));

    tmp_node->next = new_node;

    return 0;
}

单向循环链表

int Tail_List_Node(list_link head)
{
    if (head == NULL)
    {
        printf("头结点异常，无法尾插!\n");
        return -1;
    }

    // 获取尾结点
    list_link tmp_node = NULL;
    for (tmp_node=head->next; tmp_node->next != head; tmp_node=tmp_node->next);

    // 创建新的节点
    list_link new_node = Create_List_Node();
    if (new_node == (list_link)-1)
    {
        printf("创建新节点失败!\n");
        return -1;
    }

    tmp_node->next = new_node;
    new_node->next = head;

    return 0;
}

（4）遍历单项向(循环)链表

单向链表

int Show_List_Data(list_link head)
{

    if (head == NULL)
    {
        printf("头结点异常！\n");
        return -1;
    }
    else if (head->next == NULL)
    {
        printf("空链表，不需要遍历！\n");
        return 0;
    }
    else
    {
        for (list_link tmp_node = head->next; tmp_node != NULL; tmp_node = tmp_node->next)
        {
            printf("%d\n", tmp_node->data);
        }
    }

    return 0;
}

单向循环链表

int Show_List_Node(list_link head)
{
    if (head == NULL)
    {
        printf("头节点异常，无法遍历!\n");
        return -1;
    }

    if (head->next == head)
    {
        printf("空链表，无需遍历!\n");
        return 0;
    }

    for (list_link tmp_node=head->next; tmp_node != head; tmp_node = tmp_node->next)
    {
        printf("%d\n",tmp_node->data);
    }
    return 0;
}

（5）检索指定的数据节点

单向链表

list_link Find_List_Node(list_link head, int search_mode)
{

    if (head == NULL)
    {
        printf("头结点异常！\n");
        return (list_link)-1;
    }
    else if (head->next == NULL)
    {
        printf("空链表，无需检索！\n");
        return (list_link)0;
    }
    else
    {
        int obj_data;
        printf("请输入要指定的数据:");
        scanf("%d", &obj_data);

        for (list_link obj_node = head; obj_node->next != NULL; obj_node = obj_node->next)
        {
            if (obj_data == obj_node->next->data)
            {
                printf("击中目标节点!\n");
                if (search_mode == SEARCH_PRESENT_NODE)
                {
                    return obj_node->next;
                }
                if (search_mode == SEARCH_BEFORE_NODE)
                {
                    return obj_node;
                }

            }
        }
    }

    printf("链表中没有该数据!\n");

    return (list_link)-2;
}

单向循环链表

list_link Find_List_Node(list_link head, int search_mode)
{
    if (head == NULL)
    {
        printf("头节点异常，无法检索!\n");
        return (list_link)-1;
    }

    if (head->next == head)
    {
        printf("空链表,无需检索!\n");
        return (list_link)0;
    }

    int obj_data;
    printf("请输入要指定的数据:");
    scanf("%d",&obj_data);

    for (list_link obj_node=head; obj_node != head; obj_node = obj_node->next)
    {
        if (obj_data == obj_node->next->data)
        {
            printf("击中目标节点!\n");
            if (search_mode == SERACH_PRESENT_NODE)
            {
                return obj_node->next;
            }
            
            if (search_mode == SERACH_BEFORE_NODE)
            {
                return obj_node;
            }
        }
    }
    printf("链表中没有该数据!\n");
    return (list_link)-2;
}

（6）删除指定的节点数据

单向链表

int Del_List_Node(list_link head)
{

    if (head == NULL)
    {
        printf("头结点异常，无法删除！\n");
        return -1;
    }
    else if (head->next == NULL)
    {
        printf("空链表，无需删除!\n");
        return -1;
    }
    else
    {
        // 链表里面存在数据，需要先输入要删除的节点，然后判断是否存在，存在则进行删除
        // 这里需要使用Find_List_Node 去寻找到当前节点的上一个节点
        list_link before_del_node = Find_List_Node(head, SEARCH_BEFORE_NODE);
        if (before_del_node == (list_link)-2)
        {
            printf("没有该数据节点，删除操作失败!\n");
            return -1;
        }

        // 备份一下要删除的节点
        list_link del_node = before_del_node->next;

        before_del_node->next = before_del_node->next->next;
        
        del_node->next = NULL;
        free(del_node);

    }

    return 0;
}

单向循坏链表

int Del_List_Node(list_link head)
{

    if (head == NULL)
    {
        printf("头结点异常，无法删除！\n");
        return -1;
    }
    else if (head->next == head)
    {
        printf("空链表，无需删除!\n");
        return -1;
    }
    else
    {
        // 链表里面存在数据，需要先输入要删除的节点，然后判断是否存在，存在则进行删除
        // 这里需要使用Find_List_Node 去寻找到当前节点的上一个节点
        list_link before_del_node = Find_List_Node(head, SEARCH_BEFORE_NODE);
        if (before_del_node == (list_link)-2)
        {
            printf("没有该数据节点，删除操作失败!\n");
            return -1;
        }

        // 备份一下要删除的节点
        list_link del_node = before_del_node->next;

        before_del_node->next = before_del_node->next->next;
        
        del_node->next = NULL;
        free(del_node);

    }

    return 0;
}

（6）任意位置添加

单向链表

int Anywhere_Add_Node(list_link head)
{
    if (head == NULL)
    {
        printf("头结点异常!\n");
        return -1;
    }
    else if (head->next == NULL)
    {
        printf("空链表,无法指定位置添加，默认进行头插法!\n");

        if (Head_Add_Node(head) == -1)
        {
            printf("头插法添加新结点失败!\n");
            return -1;
        }
    }
    else
    {
        // 链表中存在数据 先键入要指定的位置，再检索有没有这个位置
        list_link obj_node = Find_List_Node(head, SEARCH_PRESENT_NODE);
        if (obj_node == (list_link)-2)
        {
            printf("没有该数据结点，指定位置添加失败!\n");
            return -1;
        }

        list_link new_node = Create_List_Node();
        if (new_node == (list_link)-1)
        {
            printf("新结点创建失败!指定位置添加数据失败！\n");
            return -1;
        }

        printf("请输入要添加的新数据：");
        scanf("%d", &new_node->data);

        new_node->next = obj_node->next;
        obj_node->next = new_node;
    }

    return 0;
}

单向循坏链表

int Anywhere_Add_Node(list_link head)
{
    if (head == NULL)
    {
        printf("头结点异常!\n");
        return -1;
    }
    else if (head->next == head)
    {
        printf("空链表,无法指定位置添加，默认进行头插法!\n");

        if (Head_Add_Node(head) == -1)
        {
            printf("头插法添加新结点失败!\n");
            return -1;
        }
    }
    else
    {
        // 链表中存在数据 先键入要指定的位置，再检索有没有这个位置
        list_link obj_node = Find_List_Node(head, SEARCH_PRESENT_NODE);
        if (obj_node == (list_link)-2)
        {
            printf("没有该数据结点，指定位置添加失败!\n");
            return -1;
        }

        list_link new_node = Create_List_Node();
        if (new_node == (list_link)-1)
        {
            printf("新结点创建失败!指定位置添加数据失败！\n");
            return -1;
        }

        printf("请输入要添加的新数据：");
        scanf("%d", &new_node->data);

        new_node->next = obj_node->next;
        obj_node->next = new_node;
    }

    return 0;
}

（7）移动指定数据节点

单向链表

int Move_List_Node(list_link head)
{
    if (head == NULL)
    {
        printf("头节点异常！\n");
        return -1;
    }
    else if (head->next == NULL)
    {
        printf("空链表, 无需移动！\n");
        return 0;
    }
    else if (head->next->next == NULL)
    {
        printf("只有一个数据，无需移动！\n");
        return 0;
    }
    else
    {
        list_link before_obj_node = Find_List_Node(head, SEARCH_BEFORE_NODE);
        if (before_obj_node == (list_link)-2)
        {
            printf("没有该数据节点，无法移动！\n");
            return -1;
        }

        list_link select_node = Find_List_Node(head, SEARCH_PRESENT_NODE);
        if (select_node == (list_link)-2)
        {
            printf("没有该数据节点，无法移动！\n");
            return -1;
        }

        if (before_obj_node->next == select_node)
        {
            printf("同一个节点，无需操作！\n");
            return 0;
        }

        // 先断开那个目标节点
        list_link obj_node = before_obj_node->next;
        before_obj_node->next = obj_node->next;
        obj_node->next = NULL;
        // 再将目标节点接到某个节点之后
        obj_node->next = select_node->next;
        select_node->next = obj_node;
    }

    return 0;
}

单向循坏链表

int Move_List_Node(list_link head)
{
    if (head == NULL)
    {
        printf("头结点异常，无法移动!\n");
        return -1;
    }

    if (head->next == head)
    {
        printf("空链表，无需移动!\n");
        return 0;
    }

    if (head->next->next == head)
    {
        printf("只有一个数据，无需移动!\n");
        return 0;
    }

    list_link before_obj_node = Find_List_Node(head, SERACH_BEFORE_NODE);
    if (before_obj_node == (list_link)-2)
    {
        printf("没有该数据节点,无法移动!\n");
        return -1;
    }

    list_link select_node = Find_List_Node(head, SERACH_PRESENT_NODE);
    if (select_node == (list_link)-2)
    {
        printf("没有该数据节点，无法移动!\n");
        return -1;
    }

    if (before_obj_node->next == select_node)
    {
        printf("同一个节点，无需操作!\n");
        return 0;
    }

    // 断开目标节点
    list_link obj_node = before_obj_node->next;
    before_obj_node->next = obj_node->next;
    obj_node->next = NULL;
    // 再将目标节点接到某个节点之后
    obj_node->next = select_node->next;
    select_node->next = obj_node;

    return 0;
}

（8）销毁链表

单向链表

int Destory_List(list_link head)
{
    if (head == NULL)
    {
        printf("头结点异常,无法摧毁!\n");
        return -1;
    }
    else if (head->next == NULL)
    {
        printf("空链表，直接释放头结点!\n");
        free(head);
        return 0;
    }
    else 
    {
        list_link tmp_node = head->next;
        list_link free_node = head->next;
        
        while (tmp_node != NULL)
        {
            tmp_node = free_node->next;
            head->next = free_node->next;
            free_node->next = NULL;
            free(free_node);

            free_node = tmp_node;
            printf("-----\n");
        }
        
        free(head);
    }

    return 0;
}

单向循坏链表

int Destory_List(list_link head)
{
    if (head == NULL)
    {
        printf("头节点异常,无法销毁!\n");
        return -1;
    }

    if (head->next == head)
    {
        printf("空链表，直接释放头结点!\n");
        free(head);
        return 0;
    }

    list_link tmp_node = head->next;
    list_link free_node = head->next;
    
    while (tmp_node != head)
    {
        tmp_node = free_node->next;
        head->next = free_node->next;
        free_node->next = NULL;
        free(free_node);

        free_node = tmp_node;
        printf("----\n");
    }

    free(head);

    return 0;
}

weixin_52545652
关注
专栏目录
【单循环链表的遍历】
weixin_53500185的博客
03-09 1362
单循环链表的遍历 【题目】：写一个对单循环链表进行遍历（打印每个结点的值）的算法，已知链表中任意结点的地址为p typedef struct linknode { int data; struct linknode *next; }ListNode; 【输入形式】输入结点个数，再输入结点值 【输出形式】每个结点占一行 【样例输出】 5 5 4 3 2 1 【持续输出】 5 4 3 2 1 【代码实现】 #include <stdio.h> #include<stdlib.h> typ
单向链表的遍历
Patrick_2003_01的博客
12-19 626
单向链表的遍历
单向循环链表的实现
最新发布
whx的博客
08-20 152
有了单向链表的实现，但是单向链表的遍历需要从头节点开始，直到尾节点结束，这就会有许多限制，比方说在不知道头节点的情况下，就无法通过单向链表来遍历，这时候就需要单向循环链表。单向循环链表可以从任意节点位置开始，一直循环遍历到该节点本身结束，只需要知道任意一个节点。而且单向链表在进行尾插法的时候，需要特殊处理，因为尾节点没有下一个节点，而单向循环链表中，尾节点的下一个节点就是头节点，操作上更加统一和简便。同样也是引用辅助指针，和一个临时指针，防止释放后找不到下一个节点的内容导致释放失败。
C语言实现单向（循环）链表的创建和遍历
lightingfuture的博客
08-24 8349
本代码在QT控制台环境下测试通过，如果在其他IDE下，注意修改包含的打印头文件即可。 include include include /* *2018-08-24 13:23:03 * 单向链表测试 * 包括循环链表的实现 */ using namespace std; typedef struct Node{ struct Node *next; ...
单链表的遍历
m0_57248752的博客
03-13 2276
单链表的简单介绍和遍历
python单向链表的基本操作细节（小白入门）
12-21
【Python 单向链表的基本操作细节】 链表是一种数据结构，它不同于数组，它将数据元素分散在内存的不同位置，而不是连续存储。单向链表是链表的一种形式，其中每个节点包含一个数据元素和一个指向下一个节点的引用...
单向链表基本操作的递归实现
08-10
在本文中，我们将探讨如何使用递归实现单向链表的一些基本操作。 1. **统计节点个数**：`count_listnode`函数通过递归遍历链表，计算节点总数。在递归调用中，它首先检查当前节点是否非空，然后递增计数器`count`，...
单向链表类模板_单向链表类模板_fastchq_
10-03
单向链表类模板的基本结构通常包括以下几个部分： 1. **节点定义**：首先，我们需要定义一个节点结构体（或类），它包含一个数据成员和一个指向下一个节点的指针。例如： ```cpp template struct ListNode { T...
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
循环链表遍历的猫腻
博客
03-08 2819
循环链表 循环链表的结构和单链表结构一样，只是单链表的尾结点的next指针指向null，循环链表的尾结点的next指针指向头节点，仅此而已。 图示： 循环链表的其它操作同单链表，但对于遍历循环链表就有一些小技巧了。 循环链表的遍历 第一种： public static void printList(Node head){ Node cur = head; while(cur....
遍历单向链表中的方法
m0_74558517的博客
07-03 385
4.仿照forEach源码写。
数据结构-单链表
weixin_43790838的博客
09-03 430
链表是一个有序的列表。1、链表是以节点的方式来存储,是链式存储 2、每个节点包含 data 域， next 域：指向下一个节点. 3、如图：发现链表的各个节点不一定是连续存储. 4、链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定内存布局： 逻辑布局： 直接添加思路： 一、添加（创建） 1、先创建一个head 头节点， 作用就是表示单链表的头 2、后面我们每添加一个节点，就直接加入到 链表的最后 二、遍历： 1、通过一个辅助变量遍历，帮助遍历整个链表，为null 终止按顺序添加节点思路： 1
【数据结构】单链表的创建、逆置、遍历（C语言实现）
一个学生の乱记
02-27 451
实参向形参的数据传递是“值传递”，单向传递，只能由实参传给形参，而不能由形参传递给实参。所以本次实验我们传递给函数的是头结点的地址，使得函数通过地址找到头结点，并对头结点进行操作，而不能直接传递头结点，否则对头结点的操作将在函数结束时被释放。在本次实验中，我了解到结构体可以使用typedef函数，为算法代码的编写带来了极大的便利。struct LinkList 以及 struct LinkList* 均可用一个单词代替，使得主程序的编写更难出错，保持了较高的正确性，并且增加了程序的可读性。
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3285
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
python实现·数据结构与算法之单向循环链表
南风以南
06-28 319
单向循环链表定义 单向循环链表(Single Cycle Linked List)是单链表的一个变形，将链表中最后一个节点的next域不再为None，而是指向链表的头节点。 节点示意图 单向循环链表示意图 单向循环链表的基本操作 is_empty() 判断链表是否为空 length 链表长度 travel() 遍历整个链表，打印元素 add(item) 在链表头部添加元素 append(item) 在链表尾部添加元素 insert(pos, item) 在指定位置插入元素 remove(item)
单向链表的遍历、查找
Cowcqw的博客
02-17 6756
单向链表的创建在这里不在赘述，详细请看另一篇文章《单向链表的创建》。在本篇文章中，主要通过举例的方式来帮大家理解单向链表的基本遍历。本篇文章中创建节点用以下表示typdef struct node{     int date;//定义数据域     struct node * next;//定义指针域 } ElemSN; 例一：输出单向链表尾节点的值void PrintTail(El...
循环单链表基本操作
weixin_33958366的博客
11-17 362
#include<iostream> using namespace std; #include<malloc.h> #define ElemType int typedef struct LNode { ElemType data; struct LNode *next; }LinkNode; void InitLi...
C语言实现单向链表的基本操作
"这篇资源是关于单向链表的基础知识，包括如何在C语言中实现单向链表的初始化、创建、销毁等操作。" 在数据结构中，链表是一种...这些操作在实际编程中都十分常见，理解和熟练掌握单向链表的这些基本函数至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值