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

最新推荐文章于 2024-05-21 19:00:05 发布
最新推荐文章于 2024-05-21 19:00:05 发布
阅读量219 收藏 4
点赞数 2
分类专栏： 数据结构 文章标签： c语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52545652/article/details/130148520
版权

（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
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表基本操作的递归实现
08-10
这几天正在复习一些基本的算法和实现，今天看了看递归的基本原理，发现自己对递归还不是特别清楚，特别是不清楚递归的思想，不能很准确的把握先分解成小事件，在合并的思想，其实也是数学归纳法的程序体现，其实数学归纳法是一种强大的方法，记得高中的时候最喜欢做的题目就是数学归纳方面的证明，现在想过来好多问题我不能采用这种方式思考，可见知识真的是有联系的，只是我们没有找到联系的方式而已。
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
【数据结构】—C语言实现单链表（超详细！）
B1ue还在专注
08-02 3760
这是作者对于单链表学习历程的记录，C语言做到了单链表的实现!很详细，细节都很到位！
单链表的基本操作代码实现(C语言版)
热门推荐
m0_67647682的博客
08-04 3万+
单链表基本操作取值、按值查找返回元素所在地址、按值查找返回元素所对应序号、结点插入和删除以及头插法和尾插法建立单链表等的实现与解析，链表学习记录。
单链表的遍历
m0_57248752的博客
03-13 2017
单链表的简单介绍和遍历
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2223
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
C语言链表剖析——带你了解链表的一切（一）
小哥的博客
07-07 289
链表的初识①链表前知识②链表 ①链表前知识 我们知道数据变量从变量值存在的时间（即生存期）角度分：静态存储方式和动态存储方式 静态：在编译时确定了固定的内存地址与内存大小，如：函数里的局部变量、全局变量等 动态：由程序控制，运行时主动性的向系统申请所需大小的内存段，并且每次分配到的内存地址不固定 我们知道内存的储存区域分为 程序代码区：存放函数体的二进制代码 静态区/全局区（static）：全局变量和静态变量的存储区域 堆区（heap）：程序员分配释放 栈区（stack）：由编译器自动分配释放 ，存放函数的
【数据结构】 循环单链表的基本操作 （C语言版）
weixin_56814370的博客
01-21 717
【数据结构】 循环单链表的基本操作 （C语言版）
【数据结构】单链表的创建、逆置、遍历（C语言实现）
一个学生の乱记
02-27 380
实参向形参的数据传递是“值传递”，单向传递，只能由实参传给形参，而不能由形参传递给实参。所以本次实验我们传递给函数的是头结点的地址，使得函数通过地址找到头结点，并对头结点进行操作，而不能直接传递头结点，否则对头结点的操作将在函数结束时被释放。在本次实验中，我了解到结构体可以使用typedef函数，为算法代码的编写带来了极大的便利。struct LinkList 以及 struct LinkList* 均可用一个单词代替，使得主程序的编写更难出错，保持了较高的正确性，并且增加了程序的可读性。
python单向链表的基本操作细节（小白入门）
12-21
今天是人生第一次写博客，记录自己学习的每一步，有些写...且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 什么意思呢，我们在使用python列表的时候，如果我们需要删除列表
单向链表的操作____
05-17
单向链表的创建、打印、某个元素的查找和删除（可查找和删除重复数据）、整个链表的删除等
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
单向循环链表的基本操作（头插，尾插，从任意结点处遍历整个链表）
小菜鸟的进阶
01-30 3321
单向循环链表与单链表的区别： 单向循环链表： 1.尾结点的指针域指向首结点，可以通过任意结点遍历整个链表 tail->next = head; 2.为空链表时，头结点指向自己 head->next = head; 单链表： 1.尾结点的指针域指向NULL，只可以通过头结点遍历整个链表 tail = NULL; 2.为空链表时，...
单向循环链表基本操作
icquu的博客
10-14 481
C和其他语言都一样，只是关键字更少，更接近硬件，底层操作大都需要用C中的头文件和库函数来实现。学习的过程也不乏乐趣，在入门阶段，不建议大家去磨练算法，非常枯燥。建议学习一些系统编程和网络编程，趣味性更强，也能做一些有用的东西，不会乏味到失去兴趣。等过了这个阶段，对C的认识已经比较全面和具有一定深度了，再去看一些算法相关的，也不会觉得很复杂了。后期，不管用什么语言都完全是个人思维的表达，不影响表达思...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 2985
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
单链表的算法之头部插入节点
weixin_46571142的博客
12-22 1736
1.从头部添加新节点 (1)注意写代码过程中的箭头符号，和说话过程中的指针指向。这是两码事，容易搞混。箭头符号实际上是用指针方式来访问结构体，所以箭头符号的实质是访问结构体中的成员。更清楚一点说程序中的箭头和链表的连接没有任何关系；链表中的节点通过指针指向来连接，编程中表现为一个赋值语句（用=来进行连接），实质是把后一个节点的首地址，赋值给前一个节点中的pNext元素做为值。 #include <stdio.h> //构建一个链表的节点 struct node { int data;
单向链表的基本操作
Cecilia3333的博客
03-25 224
linklist.h#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;stddef.h&gt; typedef char LinkNodeType; typedef struct LinkNode{ struct LinkNode* next; LinkNodeType data; }LinkNode; void ...
[Algorithms][C]Singly linked list
csy_best的博客
06-04 89
插入：头插入，尾插入，及指定位置插入 删除：头删除，尾删除，及指定位置插入 逆序: 查找： 计数： 打印： #include <stdio.h> #include <Windows.h> //节点结构体 #define MAX_LEN_IN_KEY 16 typedef struct Node { char key[MAX_LEN_IN_KEY+1]; ...
【LinuxC语言】目录操作
最新发布
m0_62599305的博客
05-21 117
在Linux系统中，目录操作是文件系统管理的重要组成部分。对于使用C语言进行系统编程的开发者来说，熟悉和掌握目录操作函数是必不可少的。这些函数使开发者能够创建、删除、读取和遍历目录，从而实现对文件系统的精细控制。本文将详细介绍Linux系统中C语言用于目录操作的常用函数，涵盖其函数原型、参数、返回值及示例代码，帮助读者全面理解和运用这些函数。Linux系统中，C语言提供了丰富的目录操作函数，使得开发者可以方便地管理和操作文件系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值