数据结构-链表基础详解(超详细代码)

已于 2022-12-12 21:45:16 修改
阅读量3.2k 收藏 63
点赞数 13
分类专栏： c语言学习 文章标签： 链表 学习 数据结构
于 2022-12-04 14:10:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mayu_xuan/article/details/128171526
版权

目录

一、线性表

 1.线性表定义

2.线性表特点

二、线性表的顺序表示（顺序表）

1、顺序表的优缺点

2.插入操作

3.删除操作

4.顺序表完整代码

5.练习

三、线性表的链式表示（单链表）

1.单链表定义

2.单链表优缺点

3.插入操作

4.删除操作

 5.查找操作

5.1按序号查找结点

 5.2按值查找结点

6.链表完整代码

7.练习

一、线性表

 1.线性表定义

有n(n>=0)个相同类型的元素组成的有序集合。

L=(a1,a2,......,a(i-1),ai,a(i+1),......,an)

线性表中元素个数n，称为线性表的长度。当n=0时，为空表。
a1是唯一的“第一个"”数据元素， an是唯一的“最后一个”数据元素。
ai-1为ai的直接前驱， ai+1为ai的直接后继。

2.线性表特点

2.1表中元素的个数是有限的。
2.2表中元素的数据类型都相同。意味着每一个元素占用相同大小的空间
2.3表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序

二、线性表的顺序表示（顺序表）

顺序表的定义 ：

#define MaxSize 50 //定义线性表的长度
typedef struct{
ElemType data[MaxSize]; //顺序表的元素
int len; //顺序表的当前长度
}SqList; //顺序表的类型定义

1、顺序表的优缺点

1.优点：

1.1可以随机存取（根据表头元素 地址和元素序号）表中任意一个元素。
1.2存储密度高，每个结点只存储 数据元素。
2.缺点
2.1插入和删除操作需要移动大量元素。
2.2线性表变化较大时，难以确定存储空间的容量。
2.3存储分配需要一整段连续的存储空间，不够灵活。

2.插入操作

最好情况：在表尾插入元素，不需要移动元素，时间复杂度为O(1)。

最坏情况：在表头插入元素，所有元素依次后移，时间复杂度为O(n)。
平均情况：在插入位置概率均等的情况下，平均移动元素的次数为n/2，时间

复杂度为O(n)。

代码片段：

//判断插入位置i是否合法（满足1≤i≤len+1）
//判断存储空间是否已满（即插入x后是否会超出数组长度）
for(int j=L.len;j>=i;j--) //将最后一个元素到第i个元素依次后移一位
L.data[j]=L.data[j-1];
L.data[i-1]=x; //空出的位置i处放入x
L.len++; //线性表长度加1

 注意：线性表第一个元素的数组下标是0；

3.删除操作

 最好情况：删除表尾元素，不需要移动元素，时间复杂度为O(1)。

最坏情况：删除表头元素，之后的所有元素依次前移，时间复杂度为O(n)。
平均情况：在删除位置概率均等的情况下，平均移动元素的次数为(n-1)/2，
时间复杂度为O(n)。
代码片段： 
//判断删除位置i是否合法（满足1≤i≤len）
e=L.data[i-1]; //将被删除的元素赋值给e
for(int j=i;j<L.len;j++) //将删除位置后的元素依次前移
L.data[j-1]=L.data[j];
L.len--;

4.顺序表完整代码

#include <stdio.h>

#define MaxSize 50
typedef int ElemType;//让顺序表存储其他类型元素时，可以快速完成代码修改
typedef struct{
    ElemType data[MaxSize];
    int length;//顺序表长度
}SqList;
//顺序表的插入，因为L会改变，因此我们这里要用引用,i是插入的位置
bool ListInsert(SqList &L,int i,ElemType element)
{
    //判断i是否合法
    if(i<1 || i>L.length+1)
    {
        return false;
    }
    //如果存储空间满了，不能插入
    if(L.length==MaxSize)
    {
        return false;//未插入返回false
    }
    //把后面的元素依次往后移动，空出位置，来放要插入的元素
    for(int j=L.length;j>=i;j--)
    {
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=element;//放入要插入的元素
    L.length++;//顺序表长度要加1
    return true;//插入成功返回true
}

//打印顺序表
void PrintList(SqList L)
{
    int i;
    for(i=0;i<L.length;i++)
    {
        printf("%3d",L.data[i]);//为了打印到同一行
    }
    printf("\n");
}

//删除顺序表中的元素,i是要删除的元素的位置，e是为了获取被删除的元素的值
bool ListDelete(SqList &L,int i,ElemType &e)
{
    //判断删除的元素的位置是否合法
    if(i<1 || i>L.length)
    {
        return false;//一旦走到return函数就结束了
    }
    e=L.data[i-1];//首先保存要删除元素的值
    int j;
    for(j=i;j<L.length;j++)//往前移动元素
    {
        L.data[j-1]=L.data[j];
    }
    L.length--;//顺序表长度减1
    return true;
}
//查找某个元素的位置，找到了就会对应位置,没找到就返回0
int LocateElem(SqList L,ElemType element)
{
    int i;
    for(i=0;i<L.length;i++)
    {
        if(element==L.data[i])
        {
            return i+1;//因为i是数组的下标，加1以后才是顺序表的下标
        }
    }
    return 0;//循环结束没找到
}

//顺序表的初始化及插入操作实战
int main() {
    SqList L;//定义一个顺序表，变量L
    bool ret;//ret用来装函数的返回值
    L.data[0]=1;//放置元素
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//设置长度
    ret=ListInsert(L,2,60);
    if(ret)
    {
        printf("insert sqlist success\n");
        PrintList(L);
    }else{
        printf("insert sqlist failed\n");
    }
    printf("----------------------\n");
    ElemType del;//删除的元素存入del中
    ret=ListDelete(L,1,del);
    if(ret)
    {
        printf("delete sqlist success\n");
        printf("del element=%d\n",del);
        PrintList(L);//顺序表打印
    }else{
        printf("delete sqlist failed\n");
    }
    int pos;//存储元素位置
    pos=LocateElem(L,60);
    if(pos)
    {
        printf("find this element\n");
        printf("element pos=%d\n",pos);
    }else{
        printf("don't find this element\n");
    }
    return 0;
}

5.练习

初始化顺序表（顺序表中元素为整型），里边的元素是1,2,3，然后通过scanf读取一个元素（假如插入的是6），插入到第2个位置，打印输出顺序表，每个元素占3个空格，格式为1  6  2  3，然后scanf读取一个整型数，是删除的位置（假如输入为1），然后输出顺序表  6  2  3，假如输入的位置不合法，输出false字符串。

Input

第一次输入插入的元素值，第二次输入删除的位置

Output

假如插入的元素为6，那么输出为
1  6  2  3

假如删除的位置为1，那么输出为


6  2  3

Sample Input 1 

6
1

Sample Output 1

  1  6  2  3
  6  2  3

Sample Input 2 

9
3

Sample Output 2

  1  9  2  3
  1  9  3

Sample Input 3 

9
6

Sample Output 3

  1  9  2  3
false

代码：

#include <stdio.h>
#include <stdlib.h>

#define MaxSize 50
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int length;
}SqList;

//链表插入
bool ListInsert(SqList &L,int i, ElemType ist)
{
    if(i < 1 || i > L.length + 1)
        return false;
    if (L.length >= MaxSize)
        return false;
    for (int j = L.length; j >= i; --j) {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = ist;
    L.length++;
    return true;
}

//链表删除
 bool ListDelete(SqList &L,int pos)
 {
     if(pos < 1 || pos > L.length)
         return false;
    if(L.length >= MaxSize)
        return false;
    for(int i = pos - 1; i <= L.length - 1; i++)
    {
        L.data[i] = L.data[i + 1];
    }
    L.length--;
     return true;
 }
int main() {
    SqList L;
    L.data[0] = 1;
    L.data[1] = 2;
    L.data[2] = 3;
    L.length = 3;
    ElemType ist;
    scanf("%d",&ist);
    bool ret = ListInsert(L,2,ist);
    if(ret){
        for (int i = 0; i < L.length; i++)
        {
            printf("%3d",L.data[i]);
        }
        printf("\n");
    }
    else
        printf("false\n");
    ElemType pos;
    scanf("%d",&pos);
    ret = ListDelete(L,pos);
    if (ret){
        for (int i = 0; i < L.length; i++)
        {
            printf("%3d",L.data[i]);
        }
        printf("\n");
    }
    else
        printf("false\n");
    return 0;
}

三、线性表的链式表示（单链表）

1.单链表定义

 单链表结点的定义：

typedef struct LNode{ //单链表结点类型
ElemType data; //数据域
struct LNode *next; //指针域
}LNode, *LinkList;

 头指针：链表中第一个结点的存储位置，用来标识单链表。 头结点：在单链表第一个结点之前附加的一个结点，为了操作上的方便。

        若链表有头结点，则头指针永远指向头结点，不论链表是否为空，头指针均不为 空，头指针是链表的必须元素，他标识一个链表。 头结点是为了操作的方便而设立的，其数据域一般为空，或者存放链表的长度。 有头结点后，对在第一结点前插入和删除第一结点的操作就统一了，不需要频繁 重置头指针。但头结点不是必须的。

2.单链表优缺点

1、优点：

1.1 插入和删除操作不需要移动元 素，只需要修改指针。 

1.2 不需要大量的连续存储空间。

2、缺点

2.1 单链表附加指针域，也存在浪 费存储空间的缺点。

2.2 查找操作时需要从表头开始遍历，依次查找，不能随机存取。

3.插入操作

创建新结点代码：

q=(LNode*)malloc(sizeof(LNode))
q->data=x;

(a) (b)操作的代码：

q->next=p->next;
p->next=q;

(c)操作的代码：

p->next=q;
q->next=NULL;

4.删除操作

(a)(b)(c)操作的代码：

p=GetElem(L,i-1);//查找删除位置的前驱节点
q=p->next;
p->next=q->next;
free(q);

 5.查找操作


5.1按序号查找结点

代码：

LNode *p = L->next;
int j = 1;
while(p && j<i){
    p = p->next;
    j++;
}
retrun p;

 5.2按值查找结点

代码：

LNode *p = L->next;
while(p!=NULL && p->date!=e){
    p = p->next;
}
return p;

6.链表完整代码

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
//输入3,4,5,6,7,9999
void list_head_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头结点空间，头指针指向头结点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s;//用来指向申请的新结点
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;//s的next指向原本链表的第一个结点
        L->next=s;//头结点的next，指向新结点
        scanf("%d",&x);
    }
}
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头结点空间，头指针指向头结点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾结点的next指针
        r=s;//r要指向新的尾部
        scanf("%d",&x);
    }
    r->next=NULL;//让尾结点的next为NULL
}

void print_list(LinkList L)
{
    L=L->next;
    while(L!=NULL)
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//按位置查找
LinkList GetElem(LinkList L,int SearchPos)
{
    int j=0;
    if(SearchPos<0)
    {
        return NULL;
    }
    while(L&&j<SearchPos)
    {
        L=L->next;
        j++;
    }
    return L;
}
//按值查找
LinkList LocateElem(LinkList L,ElemType SearchVal)
{
    while(L)
    {
        if(L->data==SearchVal)//如果找到对应的值，就返回那个结点的地址
        {
            return L;
        }
        L=L->next;
    }
    return NULL;
}
//i代表插入到第几个位置
bool ListFrontInsert(LinkList L,int i,ElemType InsertVal)
{
    LinkList p= GetElem(L,i-1);
    if(NULL==p)
    {
        return false;
    }
    LinkList q;
    q=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
    q->data=InsertVal;
    q->next=p->next;
    p->next=q;
    return true;
}

//删除第i个位置的元素
//删除时L是不会变的，所以不需要加引用
bool ListDelete(LinkList L,int i)
{
    LinkList p= GetElem(L,i-1);//拿到要删除结点的前一个结点
    if(NULL==p)
    {
        return false;
    }
    LinkList q=p->next;//拿到要删除的结点指针
    p->next=q->next;//断链
    free(q);//释放被删除结点的空间
    return true;
}

//头插法，尾插法来新建链表
int main() {
    LinkList L,search;//L是链表头指针，是结构体指针类型
//    list_head_insert(L);//输入数据可以为3 4 5 6 7 9999,头插法新建链表
    list_tail_insert(L);
    print_list(L);//链表打印
//    //按位置查找
//    search=GetElem(L,2);
//    if(search!=NULL)
//    {
//        printf("Succeeded in searching by serial number\n");
//        printf("%d\n",search->data);
//    }
//    search=LocateElem(L,6);//按值查询
//    if(search!=NULL)
//    {
//        printf("Search by value succeeded\n");
//        printf("%d\n",search->data);
//    }
//    bool ret;
//    ret=ListFrontInsert(L,2,99);//新结点插入第i个位置
//    print_list(L);
    ListDelete(L,5);//删除第4个位置
    print_list(L);
    return 0;
}

7.练习

输入3 4 5 6 7 9999一串整数，9999代表结束，通过头插法新建链表，并输出，通过尾插法新建链表并输出。

注意输出要采用如下代码

//打印链表中每个结点的值
void PrintList(LinkList L)
{
L=L->next;
while(L!=NULL)
{
printf("%d",L->data);//打印当前结点数据
L=L->next;//指向下一个结点
if(L!=NULL)
{
printf(" ");
}
}
printf("\n");
}

Input

3 4 5 6 7 9999，第二行也是3 4 5 6 7 9999，数据需要输入两次

Output

如果输入是3 4 5 6 7 9999，那么输出是7 6 5 4 3，数之间空格隔开，尾插法的输出是3 4 5 6 7

Sample Input 1 

3 4 5 6 7 9999
3 4 5 6 7 9999

Sample Output 1

7 6 5 4 3
3 4 5 6 7

Sample Input 2 

1 3 5 7 9 9999
1 3 5 7 9 9999

Sample Output 2

9 7 5 3 1
1 3 5 7 9

答案：

#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//头插法
void List_head_insert(LNode* &L)
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    ElemType x;
    scanf("%d",&x);
    LinkList q;
    while (x != 9999)
    {
        q = (LinkList)malloc(sizeof(LNode));
        q->data = x;
        q->next = L->next;
        L->next = q;
        scanf("%d",&x);
    }
}

//尾插法
void List_tail_insert(LinkList &L)
{
    L = (LNode*)malloc(sizeof(LNode));
    //L->next = NULL;
    ElemType x;
    scanf("%d",&x);
    LinkList p = L,q;
    while (x != 9999)
    {
        q = (LinkList)malloc(sizeof(LNode));
        q->data = x;
        p->next = q;
        p = q;
        scanf("%d",&x);
    }
    q->next = NULL;
}

//链表打印
void print_List(LNode* L)
{
    L=L->next;
    while(L!=NULL)
    {
        printf("%d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
        if(L!=NULL)
        {
            printf(" ");
        }
    }
    printf("\n");
}

//按值查询
LinkList GetElem(LNode* L,int i)
{
    if(i < 0)
        return NULL;
    while(i-- && L)
    {
        L = L->next;
    }
    return L;
}

//按位置查询
LinkList LocateElem(LinkList L,int key)
{
    L = L->next;
    while(L)
    {
        if(L->data == key)
            return L;
        L = L->next;
    }
    return NULL;
}

//中间插入
bool ListFrontInsert(LinkList L,int pos,ElemType key) //中间插入不会改变头指针
{
    LinkList p,q;
    p = GetElem(L,pos - 1);
    if(p)
    {
        q = (LinkList)malloc(sizeof(LNode));
        q->data = key;
        q->next = p->next;
        p->next = q;
        return true;
    }
    return false;

}

int main() {
    LinkList L1,L2,search; //链表头指针
    ElemType key;
    List_head_insert(L1);
    List_tail_insert(L2);
    print_List(L1);
    print_List(L2);
    return 0;
}

m_yx
关注
  • 13
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表相关代码(C语言)
weixin_51763033的博客
08-08 1036
day 1 链表反转： //链表逆序 bool reverse_linklist(struct node *ph){ struct node *pbefore=NULL,*pafter,*pcur=NULL; pbefore=ph; pcur=ph->next; if(pcur==NULL) return false; while(pcur!=NULL){ pafter=pcur->next; //当前的下一个节点指向现在前面一个， pcur->next=pb
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6114
单链表的操作与实现
链表详解（附有C语言详细代码）
最新发布
Weirdo的博客
06-06 1643
在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。int data;// 数据域// 指针域} Node;链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。
数据结构-链表
一个努力拼搏的人
11-13 1654
这里用typedef重新定义了int类型的名称，方便以后更换类型。这里用typedef重新定义了int类型的名称，方便以后更换类型。{}DL;
数据结构——链表 原理及C语言代码实现（可直接运行版）
m0_63596031的博客
02-16 522
存储都在数据段上，而在函数内部临时开辟的则存储在栈区（记忆技巧：栈区后来先出，生命周期短，适合存储临时使用的变量，在函数执行结束时会自动被释放），堆区存放的则是在函数运行过程中开辟出来的空间，需要程序员进行手动分区以及释放，也可能程序结束时由OS回收，所以也可能会发生内存泄漏问题。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构——链表
linzixi0220的博客
12-02 1587
链表是由多个地址不连续的存储结点连接而成的一种线性表，每个存储结构不仅包含元素本身的信息（数据域），而且包含表示元素之间的逻辑关系的信息，在c/c++中采样指针来实现，称为指针域，这个逻辑关系用指针来表示就是指向在线性表中与其相连的元素的地址。在线性表中，每个元素最多只有一个前驱结点和后继结点，采样链式存储时，每个结点需要包含前驱结点或者后继结点的地址信息，其中最简单也是最常用的方法是只存储每个结点的后继结点的地址，以这种方式构成的链表称为单链表。
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
python数据结构之链表详解
09-21
链表是一种重要的数据结构，它在计算机科学中被广泛用于组织和管理数据。与数组不同，链表不依赖于连续的内存空间，而是通过节点之间的引用连接...理解并熟练掌握链表这一数据结构，对于编写高效且灵活的代码至关重要。
数据结构 双向链表的创建和读取详解及实例代码
08-31
数据结构双向链表的创建和读取详解及实例代码 双向链表是一种重要的数据结构，它允许用户从头部和尾部访问链表的任意节点，提高了查找和插入的效率。在本节中，我们将详细介绍双向链表的创建和读取，并提供实例代码...
C++ 数据结构链表的实现代码
08-31
链表是一种重要的数据结构，它在计算机科学中广泛用于存储和操作动态集合。与数组不同，链表的元素不是在连续的内存位置上，而是通过指针连接。本篇文章将详细探讨C++中链表的实现，特别是如何通过类来表示链表。 ...
链表代码详解
小程的博客
04-10 261
链表
【数据结构课程设计】单链表的基本操作（含源代码）
06-14
【数据结构课程设计】单链表的基本操作(含源代码和运行结果）VC++6.0 C/C++ 可运行
王道c语言督学营课时11作业
weixin_58262388的博客
02-27 112
【代码】王道c语言督学营课时11作业。
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2400
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //ADT 线性表（List） 链式存储结构 LinkList #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义单链表 typedef struct Node {
数据结构链表代码
weixin_37862342的博客
05-16 490
typedef struct Node {/单链表结点结构体定义/ DataType data; struct Node* next; }SLNode; void ListInitiate(SLNode **head) {/单链表初始化/ head = (SLNode)malloc(sizeof(SLNode)); (*head)->next = NULL; } int ListLength(SLNode* head) {/* 求单链表数据元素个数*/ SLNode *p = head; int si
数据结构线性表之链式结构代码及其部分功能实现
Luolimasi的博客
07-27 123
单链表代码 package 线性表单链表结构及功能实现; /*程序最大的好处 在于从链表类中创建了一个结点内部类，创建嵌套类的对象 不需要对象名 直接使用.next * * 程序仍可改进点：程序虽然存在头指针了，但我们仍可以申请一个空节点始终作为程序的第一个节点，这样能够 * 使得程序在插入 与 删除等操作时 第一节点 与其他节点操作保持一致。减少代码量。 * * */ public class LinkedList {//补充链表更新数值的功能 static class ListNod
王道OJ中级-day4作业
weixin_52386753的博客
04-17 369
输入3 4 5 6 7 9999一串整数，9999代表结束，通过头插法新建链表，并输出，通过尾插法新建链表并输出。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #define Maxsize 50 typedef struct LNode { int data; struct LNode* next; }LNode,*LinkList; //头插法 LinkList crateli
C语言定义单链表[小白自用]
weixin_45827930的博客
07-30 913
struct LNode{ ElemType data; //int data; struct LNode *next; }; //struct LNode *p = (struct LNode *)malloc(sizeof(struct LNode)); typedef struct LNode LNode; LNode *p = (LNode *)malloc(sizeof(LNode)); = typedef struct LNode{ ElemType data
单链表基本操作题目
暴力扬
12-21 609
输入3 4 5 6 7 9999一串整数，9999代表结束，通过头插法新建链表，并输出，通过尾插法新建链表并输出。
C语言链表基本操作代码
04-23
好的，以下是C语言链表基本操作的代码示例： ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node *next; }; struct Node* create_node(int data) { struct Node* new_node = (struct Node*) malloc(sizeof(struct Node)); new_node->data = data; new_node->next = NULL; return new_node; } void add_node(struct Node** head, int data) { struct Node* new_node = create_node(data); if (*head == NULL) { *head = new_node; return; } struct Node* current_node = *head; while (current_node->next != NULL) { current_node = current_node->next; } current_node->next = new_node; } void delete_node(struct Node** head, int data) { struct Node* current_node = *head; struct Node* prev_node = NULL; while (current_node != NULL && current_node->data != data) { prev_node = current_node; current_node = current_node->next; } if (current_node == NULL) { return; } if (prev_node == NULL) { *head = current_node->next; } else { prev_node->next = current_node->next; } free(current_node); } void print_list(struct Node* head) { struct Node* current_node = head; while (current_node != NULL) { printf("%d ", current_node->data); current_node = current_node->next; } printf("\n"); } int main() { struct Node* head = NULL; add_node(&head, 5); add_node(&head, 10); add_node(&head, 15); add_node(&head, 20); print_list(head); delete_node(&head, 15); print_list(head); delete_node(&head, 5); print_list(head); return 0; } ``` 以上是一个简单的链表实现，包括了节点创建、添加、删除以及遍历链表并打印数据的操作。请注意，这只是一个示例代码，实际应用时需要根据具体问题进行适当的修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值