C语言链表学习

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

何为链表？

链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。
链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。
链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。
链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。
作为有强大功能的链表，对他的操作有许多，eg：链表的创建，修改，删除，插入，输出，排序，反序，清空链表的元素，求链表的长度等等。

链表的特点

n个节点离散分配
每一个节点之间通过指针相连
每一个节点有一个前驱节点和一个后继节点
首节点没有前驱节点，尾节点没有后继节点
为何要创建链表
malloc在没有连续内存空间的时候分配会失败
解决方案:
不要一次性开辟一块连续的存储空间, 每次少开辟一点
最后利用指针将所有开辟的小的存储空间链接在一起, 组成一个整体

链表的创建

创建链表须知
首节点： 存放第一个有效数据的节点
头节点： 在单链表的第一个结点之前附设一个结点，它没有直接前驱，称之为头结点，头结点的数据域可以不存储任何信息（也可以用来存储链表的节点数），指针域指向第一个节点（首节点）的地址。头结点的作用是使所有链表（包括空表）的头指针非空
头指针： 指向头节点的指针
尾节点： 存放最后一个有效数据的节点
尾指针： 指向尾节点的指针
在这里插入图片描述
建立创建链表需要的结构体

typedef struct link{
int data; //数据域
struct link *next; //指针域
} Link;

数据域的内容自己设置，指针域存放下一个节点的地址。
malloc函数
其函数原型如下：
void *malloc(unsigned int size);
这个函数返回的是个void类型指针，所以在使用时应注意强制类型转换成需要的指针类型。
free函数
其函数原型如下：
void free(void *p);
这个函数是用来释放指针p作指向的内存区。
空链表
只有一个头指针和头结点,并且头结点没有下一个结点且没有数据

Link *createLink();
int main()
{
    Link *head = createLink();
    return 0;
}
Link*createLink()
{
    //创建一个头结点
    Link *head= (Link *)malloc(sizeof(Link));
    //可能分配失败
    if(head == NULL) exit(-1);
    //下一个节点赋值为空
    head -> next = NULL;
    return head;
}

单向不循环链表

链表头插法
1.把新结点的下一个结点指向头结点的下一个结点
2.把头结点的下一个结点指向新结点
链表数据打印

void printList(Link * head)
{
    Link *cur = head;
    while(cur->next != NULL)
    {
        cur = cur -> next;
        printf("%d\n",cur -> data);
    }
}

头插法代码

#include <stdio.h>
#include <stdlib.h>
typedef struct link
{
    int data;
    struct link *next;
} Link;
void printList(Link * head);
Link *createList_TC();
int main()
{
    //创建头结点和头指针
    Link *head = createList_TC();
    //打印数据
    printList(head);
    return 0;
}
/**
 * @brief createList 头插法创建动态链表，先进后出
 * @return 返回头指针
 */
Link *createList_TC()
{
    //创建头指针和头结点
    Link *head = (Link *)malloc(sizeof(Link));
    if(head == NULL) exit(-1);
    head -> next = NULL;
    //用一个变量表示循环条件
    //提示用户输入要保存的数据
    int num = 0;
    printf("输入保存的数据,输入1结束\n");
    scanf("%d",&num);
    while(1 != num)
    {
        Link *link= (Link *)malloc(sizeof(Link));
        //保存数据
        link-> data = num;
        //1.把新结点的下一个结点指向头结点的下一个结点
        link-> next = head -> next;
        //2.把头结点的下一个结点指向新结点
        head -> next = link;
        printf("输入保存的数据,输入1结束\n");
        scanf("%d",&num);
    }
    return head;
}

链表尾插法
1.定义变量记录最后一个结点
2.让新结点成为上一个结点的下一个结点
3.把新结点作为下一个结点的上一个结点
尾插法代码

#include <stdio.h>
#include <stdlib.h>
typedef struct link
{
    int data;
    struct link *next;
} Link;
Link *createList_WC();
void printList(Link *head);
int main()
{
    Link *head = createList_WC();
    printList(head);
    return 0;
}
/**
 * @brief createList 动态链表尾插法,先进先出
 * @return 返回头指针
 */
Link *createList_WC()
{
    //1.创建头结点和头指针
    Link *head = (Link*)malloc(sizeof(Link));
    //分配失败
    if(head == NULL) exit(-1);
    head->next = NULL;

    //定义变量控制循环
    int num = 1;
    printf("输入保存的数据，输入1结束:\n");
    scanf("%d",&num);
    //1.定义变量记录最后一个结点
    Link *cur = head;//一定要放在最外面,否则会引起值覆盖
    while(1 != num)
    {
        Link *link = (Link*)malloc(sizeof(Link));
        link->data = num;
        link->next = NULL;
        //让新结点的上一个结点的下一个结点指向新结点
        cur->next = link;
        //把新结点作为下一个结点的上一个结点
        cur = link;
        printf("输入保存的数据，输入1结束:\n");
        scanf("%d",&num);
    }
    return head;
}

单向循环链表

单向循环链表和普通的链表区别在于尾节点的next指向头节点，使得链表头尾相连，构成循环链表。
一般动态链表创建完成之后再插入节点基本都是使用头插法的方式，没有使用尾插法，这是单向链表的限制，第一没有办法直接取得尾节点的地址（非循环），当然在循环链表中是可以定义一个end节点为尾节点，可以直接取得尾节点地址，这就为非迭代取地址插入链表，直接在链表最后插入节点提供了可能性，当然应为C语言的参数传递问题，在子涵中执行插入时，end节点应为全局变量，从而使得可以变更end节点的地址。

void createEmpty_XH();
void insertLink_WC(int data);
Link *head,*end;//设为全局变量，暂未分配内存空间
int main()
{
    createEmpty_XH();//创建循环空链表
    int n=0;
    for(;n<4;n++)
    {
        insertLink_WC(n);//在链表尾端插入节点和数据
    }
    printList(head);
    return 0;
}
void printList(Link *head)//节点数保存在head.data中
{
    Link *cur = head;
    int n=0;
    printf("保存了%d组数据\n",head -> data);
    for (;n<head->data;n++)//首先判断不是空链表
    {
        cur = cur -> next;
        printf("%d\n",cur -> data);
    }
}
/**
 * @brief createEmpty 创建循环空链表
 * @return 链表的头指针
 */
void createEmpty_XH()
{
    //2.创建一个空节点, 并且赋值给头指针
    head = (Link *)malloc(sizeof(Link));
    if(head == NULL) exit(-1);
    end = (Link *)malloc(sizeof(Link));
    if(end == NULL) exit(-1);

    head->next = end;//首尾相连
    end->next=head;  
    head->data=0;
}
/**
 * @brief insertLink_WC插入节点
 * @param data 插入节点的数据
 * //此时，end要做为全局变量，或者该函数在main中直接实现（不以子函数的形式调用）
 */
void  insertLink_WC(int data)
{
    Link *link = (Link *)malloc(sizeof(Link)); // 创建一个新的节点
    if(link == NULL) exit(-1);
    Link *cur=end->next;
    cur->data++;        //head.data++

    end->data = data;   // 将数据保存到新节点中
    link->next=end->next;     //保存end.next的地址到中间节点
    cur=link;           //保存新节点地址到中间节点
    link=end;           //end的地址赋值给新节点
    end=cur;            //中间节点地址赋值给end节点
    link->next=end;     //新节点之后是end节点
}

链表常用函数封装总(head,end已设置为全局变量)

/**
 * @brief createList_TC 动态链表头插法,先进后出
 * @return 返回头指针
 */
void createList_TC()
{
    //1.创建头指针和头结点
    head = (Link *)malloc(sizeof(Link));
    if(head == NULL) exit(-1);
    head -> next = NULL;
    head->data=0;
    //1.用一个变量表示循环条件
    //2.提示用户输入要保存的数据
    int data = 0;
    printf("输入想要保存的数据，输入1结束\n");
    scanf("%d",&data);
    while(1!= data)
    {
        Link *link= (Link *)malloc(sizeof(Link));
        //保存数据
        link-> data = data;
        //1.把新结点的下一个结点指向头结点的下一个结点
        link-> next = head -> next;
        //2.把头结点的下一个结点指向新结点
        head -> next = link;
        head->data++;
        printf("输入想要保存的数据，输入1结束\n");
        scanf("%d",&data);
    }
}
/**
 * @brief createList_WC 动态链表尾插法,先进先出
 * @return 返回头指针
 */
void createList_WC()
{
    //1.创建头结点和头指针
    head = (Link*)malloc(sizeof(Link));
    //分配失败
    if(head == NULL) exit(-1);
    head->next = NULL;
    head->data=0;
    //定义变量控制循环
    int data = -1;
    printf("请输入你想要保存的数据:\n");
    scanf("%d",&data);
    //1.定义变量记录最后一个结点
    Link *cur = head;//一定要放在最外面,否则会引起值覆盖
    while(-1 != data)
    {
        Link *link = (Link*)malloc(sizeof(Link));
        link->data = data;
        link->next = NULL;
        //2.让新结点的上一个结点的下一个结点指向新结点
        cur->next = link;
        //3.把新结点作为下一个结点的上一个结点
        cur = link;
        head->data++;
        printf("请输入你想要保存的数据:\n");
        scanf("%d",&data);
    }
}
/**
 * @brief createEmpty 创建循环空链表
 * @return 链表的头指针
 */
void createEmpty_XH()
{
    //2.创建一个空节点, 并且赋值给头指针
    head = (Link *)malloc(sizeof(Link));
    if(head == NULL) exit(-1);
    end = (Link *)malloc(sizeof(Link));
    if(end == NULL) exit(-1);

    head->next = end;//首尾相连
    end->next=head;  
    head->data=0;
}
void createEmpty()
{
    //创建一个空节点, 并且赋值给头指针
    head = (Link *)malloc(sizeof(Link));
    if(head == NULL) exit(-1);
    head->next = NULL;
    head->data=0;
}
/**
 * @brief insertLink_TC插入节点
 * @param data 插入节点的数据
 */
void  insertLink_TC(int data)
{
    Link *link = (Link *)malloc(sizeof(Link)); // 1.创建一个新的节点
    if(link == NULL) exit(-1);
    link->data = data;   // 2.将数据保存到新节点中
    // 3.进行插入
    // 3.1让新节点的下一个节点 等于 头节点的下一个节点
    link->next = head->next;
    // 3.2让头结点的下一个节点 等于 新节点
    head->next = link;
    head->data++;
}
/**
 * @brief insertLink_WC插入节点
 * @param data 插入节点的数据
 * //此时，end要做为全局变量，或者该函数在main中直接实现（不以子函数的形式调用）
 */
void  insertLink_WC(int data)
{
    Link *link = (Link *)malloc(sizeof(Link)); // 创建一个新的节点
    if(link == NULL) exit(-1);
    Link *cur=end->next;
    cur->data++;        //head.data++

    end->data = data;   // 将数据保存到新节点中
    link->next=end->next;     //保存end.next的地址到中间节点
    cur=link;           //保存新节点地址到中间节点
    link=end;           //end的地址赋值给新节点
    end=cur;            //中间节点地址赋值给end节点
    link->next=end;     //新节点之后是end节点
}
/**
 * @brief insertLink插入节点
 * @param front 在第几个节点后插入节点
 * @param data  插入节点的数据
 */
int insertLink(int front,int data)
{
    if(front<(head->data+1))
    {
        int count=0;
        Link *link,*cur=head;
        link = (Link *)malloc(sizeof(Link)); //创建一个新的节点
        if(link == NULL) exit(-1);
        link->data = data;   //将数据保存到新节点中
        //进行插入
        for(;count<front;count++) cur=cur->next;
        link->next = cur->next;
        cur->next = link;
        head->data++;
        return 1;
    }
    else return 0;
}
/**
 * @brief insertData插入数据
 * @param front 插入数据的节点，是第几个
 * @param data  插入节点的数据
 */
int insertData(int front,int data)
{
    if(front<(head->data+1))
    {
        Link *cur=head;
        int count=0;
        for(;count<front;count++) cur=cur->next;
        cur->data = data;   //将数据插入到节点中
        return 1;
    }
    else return 0;
}
/**
 * @brief destroyList 销毁链表
 * @param head 链表的头指针
 */
void destroyList(Link *head)
{
    Link *cur = NULL;
    while(head != NULL)
    {
        cur = head->next;
        free(head);
        head = cur;
    }
}
/**
 * @brief findLink 查找指定节点
 * @param key 需要查找的key
 * @return 符合要求的节点, 如果找不到返回NULL
 */
Link *findLink(int key)
{
    Link *cur = head->next; //注意点:头结点不需要查找
    int count=0;
    while(count<head->data)
    {   // 判断当前节点保存的值是否是要查找的值
        if(cur->data == key) return cur;
        else cur = cur->next;
    }
    return NULL;
}
/**
 * @brief deleteLink 删除指定节点
 * @param head 链表的头指针
 * @param link 需要删除的节点
 */
void deleteLink(Link *link)
{
    Link *cur=head;
    //找到需要删除节点的上一个节点
    while(cur->next != link) cur = cur->next;
    cur->next = link->next;
    free(link);    // 3.删除对应节点
}

link->next = NULL和link!=NULL的区别：
while(link->next ！= NULL) 循环结束时，此时link的位置是尾节点的位置，但如果用于输出函数的判断条件，则尾节点的数据不会输出。
while(link!=NULL) 循环结束时， 此时link指向的位置为尾节点的下一个节点，因为没有申请内存空间，所以是一个未知的区域。

HEHEDA_释悦
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础数据结构链表
iccoke的博客
12-12 412
单链表
数据结构基本知识
LIUCHANGSHUO的博客
11-15 685
一、基本的数据结构 1、数组 2、链表 3、栈 4、队列 5、树 6、图 一.数组： 1.由n个同种类型的元素以顺序存储的方式存储在计算机内存中，数据元素的类型是一致的 2.每个元素有个下标，下标从0开始标号，数组有数组名字 3. 访问每一个具体元素的方法：数组名[下标] 列如在C语言中让a[0]到a[n]对应1到n则a[0]=1,a[1]=2.....以此类推 4.数组的优点：能够随机存取 数组的缺点：插入删除不方便，需要移动元素 二.链表： 1.结...
链表_学习笔记（C语言）
musanruqiu的博客
02-05 412
创建链表头插法：因为是往链表的前端插入新节点，所TT节点的next要指向head节点的next, 随后将head节点的next指向TT节点，便可。尾插法是在尾部增节点，head节点固定为链表的头部，r的节点的next指向s节点,创建链表尾插法：head节点为头结点。r节点为游标节点（可以认为是中间节点），
基础数据结构：单链表
友善啊，朋友的博客
09-05 1273
定义 单链表是一种线性数据结构，用一组地址任意存储单元来存储数据，存储单元分散在内存任意地址上，存储单元之间用指针连接。 单链表一般有两种： 带头结点的，头结点不存放数据，只是为了操作方便。 不带头结点的。 链表只要得到头指针就可以操作每一个结点。 示例 定义 //数据结点 template <typename T>struct linkeNode { T data; linkeNode * next{nullptr}; }; template <type
链表操作
weixin_42639771的博客
05-03 521
一、有头节点、无头节点 有头节点的链表，第一个节点一般不存数据，无头节点的，第一个节点就放数据。 我们一般使用的都是有头节点的，这样初始化的时候就获得了链表头部地址。如果使用无头节点的，那么只有在创建第一个数据节点时，才能知道链表头地址。 我们使用的时候，一般会再次封装一个结构体，将链表头部节点，放到这个结构体里。 //有头节点 phead = (struct node*)malloc(sizeo...
数据结构--链表
m0_46559069的博客
03-03 476
链表 链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 链表都有头指针，一般为heae，存放的是一个地址。链表节点分为两类，头节点和一般节点，头节点是没有数据域的。链表的每个节点都分为两部分，一个数据域，一个指针域。 以上内容摘自：https://www.cnblogs.com/ariel-dreamland/p/10469696.html 若线性表为空表，则头节点的指针域为空。 链表分为：单链表、循环链表、双向链表
C语言链表学习教案.pptx
09-30
C语言链表学习教案.pptx
C语言链表实现贪吃蛇游戏
08-29
主要介绍了C语言链表实现贪吃蛇游戏源码，适合C语言入门者学习阅读，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言链表贪吃蛇(VS2022版)
最新发布
04-29
对数组贪吃蛇的框架改良
初学者链表题不会做----看这一篇就够了（JAVA）
weixin_52206295的博客
12-24 888
目录 概念 例题 总结 概念： 链表是一种常见的基础数据结构，链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白了，链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该
单链表的两种简单实现（有头节点和无头节点）
12-09
重学数据结构第一步：简单实现下链表，功能不是很完善，重在学习思想。
链表:头结点
qq_51104566的博客
05-11 2168
简介： 头结点的数据域可以不存储任何信息，头结点的指针域存储指向第一个结点的指针（即第一个元素结点的存储位置）。头结点的作用是使所有链表（包括空表）的头指针非空，并使对单链表的插入、删除操作不需要区分是否为空表或是否在第一个位置进行，从而与其他位置的插入、删除操作一致。 简而言之： 链表的第一个结点之前附设一个结点，它没有直接前驱，称之为头结点。 附图如下： ...
【算法笔记】关于链表头结点是否需要储存数据的思考
qq_54044039的博客
07-30 4983
今天听算法网课的时候发现老师构建的链表头指针指向了一个没有数据的结点，即链表的头指针并不储存数据。而学校教材中使用的链表则不存在这样的特殊的头结点。于是我开始纠结使用哪一种形式创建链表，毕竟链表的写法不同，后续对链表的操作写法也不同。 后得出结论：如果头结点不储存数据，那做插入删除等操作时，不必考虑改动头结点的情况，变动的结点永远是后继的结点。只不过在编写链表的操作时，常常要时指针指向第二结点而不是链表首地址。 如果头结点储存数据，虽然不用特殊对待头结点，...
带头结点单链表、不带头结点单链表（头指针单链表）
weixin_50539337的博客
12-01 9159
1、头结点和头指针实现的区别 1.1记录链表的类型不同： 头指针是一个4字节的指针，记录第一个存储数据的结点的地址。 头结点是一个结构体变量，使用这个变量的next域来记录第一个存储数据的结点的地址，头结点的data域可以使用联合体的方式记录链表的长度。 1.2各个操作方法的定义不同 如果是头指针实现，则方法中国接受这个链表的类型必须是二级指针。 头指针实现使用一级指针就OK。 2、单链表 链表和顺序表的区别： （1）链表在逻辑存储上是连续的，在物理存储上是不连续的。 （2）单链表属于链表中的一种，每一个存
头结点和头指针
qq_30419463的博客
03-19 1216
头结点和头指针简介
初学JAVA资料——链表
weixin_30788239的博客
12-17 200
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一...
【数据结构】链表
qq_52989768的博客
05-08 868
链表的种类有很多，这里只挑选其中的部分种类来实现 目录 1.链表概念 2.链表分类 3.链表的实现 3.1增加数据 3.1.1头部添加数据 3.1.2尾部添加数据 3.1.3任意位置加入数据 3.2删除数据 3.2.1删除第一次出现key值的位置的节点 3.2.2删除所有位置出现key值的节点 1.链表概念 链表同样是线性表的一种，其特点是物理存储结构不连续，逻辑顺序是通过链表中的引用链接次序来实现（具体可以想象下火车车厢是如何连接的） 具体结构如下图： 节点分为...
单向链表的增删改查（包含头节点--头节点没有数据域）
weixin_48102054的博客
09-09 216
单向链表的增（头插、尾插）删改（指定改、随意改）查（随意查、指定查）
c语言链表的基本操作
07-27
c语言链表的基本操作包括创建链表、插入元素、删除元素、读取链表和销毁链表。在给出具体操作之前，我先解释一下引用内容中的代码。 引用\[1\]中的代码是作者在学习数据结构时遇到的问题和解决方法。作者通过重新学习C语言和指针相关的知识，成功地理解了指针的概念，并能够使用C语言实现数据结构中的算法。 引用\[2\]中的代码是作者在解决链表内存访问冲突问题时采用的二级指针的方法。作者通过使用二级指针，解决了链表创建后内存访问冲突的问题。 引用\[3\]中的代码是一个主函数，用于测试链表的基本操作功能。其中包括创建链表、读取链表、插入元素、删除元素和销毁链表等操作。 现在我来回答你的问题，c语言链表的基本操作如下： 1. 创建链表：创建一个头结点为head的链表。可以通过申请内存空间来创建链表，并将头结点的指针赋值给head。 2. 插入元素：在链表中指定的结点前插入元素e。可以通过遍历链表找到指定的结点，然后创建一个新的结点，并将新结点的指针指向指定结点的下一个结点，再将指定结点的指针指向新结点。 3. 删除元素：删除链表中指定的结点。可以通过遍历链表找到指定的结点，然后将指定结点的前一个结点的指针指向指定结点的下一个结点，再释放指定结点的内存空间。 4. 读取链表：读取链表的数据域并打印。可以通过遍历链表，依次读取每个结点的数据域，并将其打印出来。 5. 销毁链表：释放为链表申请的内存空间。可以通过遍历链表，依次释放每个结点的内存空间。 以上就是c语言链表的基本操作。希望对你有帮助！ #### 引用[.reference_title] - *1* *2* *3* [C语言实现链表的基本操作（超详细注释）](https://blog.csdn.net/weixin_63069485/article/details/123784826)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值