数据结构----链表

已于 2024-08-24 10:30:07 修改
阅读量2.2k 收藏 15
点赞数 64
文章标签： 数据结构 链表
于 2024-08-16 21:49:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64136247/article/details/141257878
版权

一丶概念

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

二丶特点

         特点：内存不连续，通过指针进行连接
         解决: 长度固定的问题，插入删除麻烦的问题
         逻辑结构：线性结构
         存储结构：链式存储
         操作：增删改查 
struct node
{
    int data;   //数据域：存储数据
    struct node *next;    //指针域：存储下一个节点的地址
};

三丶单向链表

1.分类

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

2.有头单向链表

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

#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.无头单向链表

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

#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.  将新节点放到链表尾部

#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；

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

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、  释放被删除节点

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) 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表头节点的下一个节点(每次插入的头节点的下一个节点位置)

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;
    }

完整的单链表操作

#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("Delete 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 DeldataLinklist(node_p p, int data)
{
   // node_p p1=(node_p)malloc(sizeof(node_t));
    node_p p1 =p->next;
    while (p1)
    {
        if (p1->data == data)
        {
            p->next=p1->next;
            free(p1);
            p1=p->next;
        }
        else
        {
            p=p->next;
            p1=p->next;
        }
    }
}
int ModifyLinklist(node_p p, int post, int data) // 修改函数
{
    if (post < 0 || post >= StrlenLinklist(p))
    {
        printf("Modify err");
        return -1;
    }
    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);
        pp = NULL;
    }
    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, 3);
    InsertLinklist(p, 4, 5);
    InsertLinklist(p, 5, 3);
    printf("原始数据\n");
    ShowLinklist(p);      // 打印数据
    DeleteLinklist(p, 0); // 删除数据
    printf("删除后的数据\n");
    ShowLinklist(p);         // 打印数据
    ModifyLinklist(p, 0, 0); // 修改数据
    printf("修改后的数据\n");
    ShowLinklist(p);
    printf("查找的数据\n");
    SearchLinklist(p, 6);
    DeldataLinklist(p, 3);
    printf("删除后的数据\n");
    ShowLinklist(p);
    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).顺序表查找方便，但是插入和删除麻烦，链表，插入和删除方便，查找麻烦

嵌入式----HR
关注
数据结构-链表里面的环
菜菜子&的博客
07-23 2615
数据结构--链表里面的环（判断是否有环，环的入口）
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构 -- 链表详解
hu_143的博客
04-27 2592
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构-链表
一个努力拼搏的人
11-13 2231
这里用typedef重新定义了int类型的名称，方便以后更换类型。这里用typedef重新定义了int类型的名称，方便以后更换类型。{}DL;
数据结构-链表篇
热门推荐
qq_16268979的博客
01-10 1万+
数据结构-链表篇
数据结构-双向链表
aaa0329的博客
05-03 1万+
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 ...
数据结构---链表
myi__的博客
11-14 1461
一：概念及结构 1.1：概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 顺序表：底层是一段连续空间---物理上是连续的，逻辑上也是连续的。 链表：物理上不一定连续，逻辑连续。链表中的元素存储在一个一个的节点当中。 1.2：结构 1.2.1：单向或者双向 1.2.2：带头或者不带头 1.2.3：循环或者非循环 1.2.4：无头单向非循环链表 1.2.5：无头双向链表 ...
数据结构-合并链表算法
weixin_62824507的博客
06-25 4889
将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间
数据结构 - 链表
qq_43629857的博客
06-16 6550
线性表的链式存储结构 - 链表
数据结构-链表（详解）
weixin_73142957的博客
05-11 2547
前言：内容包括：链表的分类，无头单向非循环链表的增删查改的实现，带头双向循环链表的增删查改的实现
数据结构-循环双链表
lzlyxxn的博客
05-08 1498
循环链表，就是把链表给首尾相连，即尾结点的next指向L头结点，而循环双链表不仅尾结点指向头结点，且头结点的prior指向尾结点，判断为空时，只要看尾结点下一个是否指向头结点，循环链表的操作和链表的操作差别并不大。 循环双链表的创建、插入、删除 #include<iostream> #include<cstdlib> using namespace std; typedef int ElemType; typedef struct CNode{ ElemType data;
数据结构-循环链表-C语言实现约瑟夫圈-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及使用循环链表实现的约瑟夫圈的main.c文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 此外循环...
2.C-数据结构-线性表-链表源码
09-07
2.C-数据结构-线性表-顺序表源码
C语言数据结构-链表版学生管理系统
10-02
《C语言数据结构-链表版学生管理系统》 在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版...
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构--树
wxdzuishaui的博客
09-14 437
【代码】数据结构--树。
数据结构之栈和队列的应用
zhj2003_的博客
09-11 910
栈和队列的应用十分广泛，本文简单地展示了这两种数据结构的特点，然而它的魅力不止这些，相信读者一定会遇到更加有趣的算法。上述内容如果有错误的地方，希望大佬们可以指正。我一直在学习的路上，您的帮助使我收获更大！我也会不断更新文章！
C 语言数据结构中的堆与栈：深入理解与应用
最新发布
Thanks_ks的IT探秘之旅
09-14 609
本文深入探讨了 C 语言中栈（Stack）与堆（Heap）的基本概念、特性及其在内存管理和算法实现中的重要作用。通过解析栈的后进先出特性及其在函数调用、表达式求值中的应用，以及堆作为特殊完全二叉树在优先队列、堆排序等场景下的广泛运用，帮助读者构建对这两种基础数据结构的全面理解。文章还提供了栈与堆的 C 语言实现示例，为实际编程提供参考。
数据结构--栈和队列
wxdzuishaui的博客
09-14 306
【代码】数据结构--栈和队列。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值