数据结构----链表

新手嵌入式学习2024-08-19 11:12

一丶概念

链表又称单链表、链式存储结构，用于存储逻辑关系为"一对一"的数据。
和顺序表不同同，使用链表存储数据，不强制要求数据在内存中集中存储，各个元素可以分散存储在内存中。

二丶特点

特点：内存不连续，通过指针进行连接
解决: 长度固定的问题，插入删除麻烦的问题
逻辑结构：线性结构
存储结构：链式存储
操作：增删改查

cs 复制代码 
struct node
{
    int data;   //数据域：存储数据
    struct node *next;    //指针域：存储下一个节点的地址
};

三丶单向链表

1.分类

有头链表：存在一个头节点，头节点数据域无效，指针域有效。
无头链表：每一个节点的数据域和指针域都有效。

2.有头单向链表

存在一个头节点，数据域无效，指针域有效

cs 复制代码 
#include <stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct node
{
    int data;//数据域
    struct node *next;//指针域
} node_t, *node_p;
int main(int argc, char const *argv[])
{
    node_t A={1,NULL};//输入数据
    node_t B={2,NULL};
    node_t C={3,NULL};
    node_t D={4,NULL};
    A.next=&B;
    B.next=&C;
    C.next=&D;
    node_p p;
    //头指针指向头节点
    node_t S = {'\0',&A};
    p=H.next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    return 0;
}

3.无头单向链表

所有节点的指针域和数据域都有效

cs 复制代码 
#include <stdio.h>
#include <stdlib.h>
typedef char datatype;
typedef struct node
{
    datatype data;     //数据域用来存数据
    struct node *next; //指针域用来存下一个节点的地址
} node_t, *node_p;

// node_t A; //等同于 struct node A;
// node_p p; //等同于 struct node *p;

int main(int argc, char const *argv[])
{
    //1.定义4个节点
    node_t A = {'a', NULL};
    node_t B = {'b', NULL};
    node_t C = {'c', NULL};
    node_t D = {'d', NULL};

    //2.连接四个节点
    A.next = &B; //连接A和B
    B.next = &C;
    C.next = &D;

    //3.定义一个头指针指向第一个节点
    node_p p = &A;

    //4. 通过指针遍历无头单向链表
    while (p != NULL)
    {
        printf("%c ", p->data); //打印节点中的数据域 a b c d
        p = p->next;            //让p指向下一个节点
    }
    printf("\n");

    return 0;
}

链表尾插法练习

写一个有头单向链表，用于保存输入的学生成绩，实现一输入学生成绩就创建一个新的节点，将成绩保存起来。再将该节点链接到链表的尾，直到输入-1结束。

要求：每个链表的节点由动态内存分配得到 , 也就是用malloc。

过程：

1. malloc申请空间link_node_t大小作为头节点

2. 将新节点放到链表尾部

cs 复制代码 
#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node
{
    int data;//数据域存放数据
    struct node *next;//指针域记录下一个结点地址
} node_t, *node_p;
void ShowLinklist(node_p p)//打印数据
{
    while(p!=NULL)
    {
    printf("%d ",p->data);
    p=p->next;
    }
    printf("\n");
}
int main(int argc, char const *argv[])
{
    int score = 0;
    // 创建一个头节点
    node_p p_head = (node_p)malloc(sizeof(node_t));
    if (NULL == p_head)//容错判断
    {
        printf("malloc err");
        return -1;
    }
    //让头指针的指针域置空
    p_head->next = NULL;
    //创建一个尾节点
    node_p p_tail = (node_p)malloc(sizeof(node_t));
    if (NULL == p_head)
    {
        printf("p_tail malloc err");
        return -1;
    }
    p_tail = p_head;//让尾节点指向头节点
    while (1)
    {
        //循环输入成绩
        scanf("%d", &score);
        //输入-1时停止结束循环
        if (score == -1)
            break;
        //新建一个节点p_new
        node_p p_new = (node_p)malloc(sizeof(node_t));
        if (NULL == p_new)//容错判断
        {
            printf("p_new malloc err");
            return -1;
        }
        p_new->data = score; //将数据存入新的节点
        p_new->next = NULL;//让新的节点的指针域置空
        p_tail->next = p_new;//让尾节点连接到新的节点
        p_tail=p_new;//更新尾节点
    }
    node_p p = p_head->next;
    ShowLinklist(p);
    return 0;
}

4.有头单向链表的函数操作

插入的思想
1. 先遍历找到要插入节点的前一个节点，假设这个节点为A；A的下一个节点为B；将C插入A与B之间；
2.先让C的指针域指向B；
3.再让A的指针域指向C；

（注意：顺序不可以调换）

cs 复制代码 
int InsertLinklist(node_p p, int post, int data) // 插入数据
{
    if (post < 0 || post > StrlenLinklist(p))
    {
        printf("Insert eerr");
        return -1;
    }
    for (int i = 0; i < post; i++) // 让p指向插入位置post的前一个节点
        p = p->next;
    node_p p_new = (node_p)malloc(sizeof(node_t)); // 创建一个新的节点
    if (NULL == p_new)                             // 容错判断
    {
        printf("p_new malloc err");
        return -1;
    }
    p_new->data = data;    // 让新节点的数据域等于新的数据
    p_new->next = p->next; // 指针域等于插入位置的地址
    p->next = p_new;       // 前一个节点的指针域等于新节点的地址
    return 0;
}

删除的思想
1.先遍历找到要删除节点的前一个节点，假设为A；
2、找一个临时指针指向要删除的节点；
3、 将A的指针域指向删除节点的下一个节点；
4、 释放被删除节点

cs 复制代码 
int DeleteLinklist(node_p p, int post) // 删除函数
{
    if (post < 0 || post >= StrlenLinklist(p))
    {
        printf("Insert eerr");
        return -1;
    }
    for (int i = 0; i < post; i++) // 让p指向删除位置post的前一个节点
        p = p->next;                                 
    node_p p1 = p->next; // 新定义一个结构体指针用来存放删除位置的地址
    p->next = p1->next;  // 让被删除位置的前一个的指针域等于被删除位置后一个节点的地址
    free(p1);            // 将被删除指针释放，指针置空
    p1 = NULL;
}

转置的思想：
(1) 将头节点与当前链表断开，断开前保存下头节点的下一个节点，保证后面链表能找得到，定义一个q保存头节点的下一个节点，断开后前面相当于一个空的链表，后面是一个无头的单向链表
(2) 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表头节点的下一个节点(每次插入的头节点的下一个节点位置)

cs 复制代码 
void ReverseLinkList(node_p p)
{

    node_p temp = NULL;//临时保存q下一个节点的地址
    //断开前，保存头节点的下一个节点的地址
     node_p q = p->next;//指向头节点的下一个节点（相当于无头单向链表的头指针）
    //1.断头，断开链表
    p->next = NULL;
    //2.遍历无头单向链表
    while (q != NULL)
    {
        //暂时存放q的下一个节点，防止链表丢失
        temp = q->next;
        //头插到有头单向链表头节点的后面
        q->next = p->next;
        p->next = q;
        //将q重新指向之前的无头单向链表，指向此时的第一个节点
        q=temp;
    }

完整的单链表操作

cs 复制代码 
#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node
{
    int data;          // 数据域存放数据
    struct node *next; // 指针域记录下一个结点地址
} node_t, *node_p;
node_p CreateEpLinkist() // 创建一个空的有头单向链表
{
    node_p p = (node_p)malloc(sizeof(node_t)); // 开辟节点空间大小
    if (NULL == p)
    {
        printf("CreatEpLinklist err");
        return NULL;
    }
    p->next = NULL; // 初始化头结点
    return p;
}
int StrlenLinklist(node_p p) // 计算单链表长度
{
    int len = 0;
    while (p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}
int InsertLinklist(node_p p, int post, int data) // 插入数据
{
    if (post < 0 || post > StrlenLinklist(p))
    {
        printf("Insert eerr");
        return -1;
    }
    for (int i = 0; i < post; i++) // 让p指向插入位置post的前一个节点
        p = p->next;
    node_p p_new = (node_p)malloc(sizeof(node_t)); // 创建一个新的节点
    if (NULL == p_new)                             // 容错判断
    {
        printf("p_new malloc err");
        return -1;
    }
    p_new->data = data;    // 让新节点的数据域等于新的数据
    p_new->next = p->next; // 指针域等于插入位置的地址
    p->next = p_new;       // 前一个节点的指针域等于新节点的地址
    return 0;
}
int DeleteLinklist(node_p p, int post) // 删除函数
{
    if (post < 0 || post >= StrlenLinklist(p))
    {
        printf("Insert err");
        return -1;
    }
    for (int i = 0; i < post; i++) // 让p指向删除位置post的前一个节点
        p = p->next;
    node_p p1 = p->next; // 新定义一个结构体指针用来存放删除位置的地址
    p->next = p1->next;  // 让被删除位置的前一个的指针域等于被删除位置后一个节点的地址
    free(p1);            // 将被删除指针释放，指针置空
    p1 = NULL;
}
void ModifyLinklist(node_p p, int post, int data) // 修改函数
{
    for (int i = 0; i <= post; i++) // 让指针指向要修改的节点位置
        p = p->next;
    p->data = data; // 指针域等于新的数据
}
void SearchLinklist(node_p p, int data)//查找数据
{
    int i = 0;
    p = p->next;
    while (p != NULL)
    {
        if (p->data == data)
        {
            printf("%d\n", i);
            break;
        }
        p = p->next;
        i++;
    }
}
void ClearLinklist(node_p p) // 清空链表
{
    node_p pp = NULL;
    node_p ppp=p->next;
    while(ppp!=NULL)
    {
        pp=ppp;
        ppp=ppp->next;
        free(pp);
    }
    p->next=NULL;
}
void ShowLinklist(node_p p) // 打印数据
{
    while (p->next) // 当指针p的指针域为空时停止循环
    {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n");
}
void ReverseLinkList(node_p p) // 链表的转置
{
    node_p temp = NULL;
    node_p q = p->next;
    p->next=NULL;
    while (q != NULL)
    {
        temp=q->next;
        q->next=p->next;
        p->next=q;
        q=temp;
    }
}
int IsEpLinklist(node_p p) // 判断链表是否为空
{
    return p->next == NULL;
}
int main(int argc, char const *argv[])
{
    node_p p = CreateEpLinkist(); // 创建一个空的有头单向链表
    InsertLinklist(p, 0, 1);      // 进行插入数据
    InsertLinklist(p, 1, 2);
    InsertLinklist(p, 2, 3);
    InsertLinklist(p, 3, 4);
    InsertLinklist(p, 4, 5);
    InsertLinklist(p, 5, 6);
    printf("原始数据\n");
    ShowLinklist(p);         // 打印数据
    DeleteLinklist(p, 0);    // 删除数据
    printf("删除后的数据\n");
    ShowLinklist(p);         // 打印数据
    ModifyLinklist(p, 0, 0); // 修改数据
    printf("修改后的数据\n");
    ShowLinklist(p);
    printf("查找的数据\n");   
    SearchLinklist(p, 6);
    printf("转置后的数据\n");
    ReverseLinkList(p);
    ShowLinklist(p); // 打印数据
    ClearLinklist(p);
    ShowLinklist(p);
    if (IsEpLinklist(p))
        printf("IsEpLinkList\n");
    free(p);
    p = NULL;
    return 0;
}

5.单向循环链表

四丶总结：

顺序表和单向链表比较：
(1).顺序表在内存当中连续存储的(数组)，但是链表在内存当中是不连续存储的，通过指针将数据链接在一起
(2).顺序表的长度是固定的，但是链表长度不固定
(3).顺序表查找方便，但是插入和删除麻烦，链表，插入和删除方便，查找麻烦

相关推荐
pianmian13 小时前
python数据结构基础(7)
数据结构·算法
ChoSeitaku6 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
偷心编程6 小时前
双向链表专题
数据结构
香菜大丸6 小时前
链表的归并排序
数据结构·算法·链表
jrrz08286 小时前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
@小博的博客6 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
南宫生7 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法
泉崎8 小时前
11.7比赛总结
数据结构·算法
你好helloworld9 小时前
滑动窗口最大值
数据结构·算法·leetcode
JSU_曾是此间年少10 小时前
数据结构——线性表与链表
数据结构·c++·算法
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除