链表 学习

最新推荐文章于 2024-09-14 21:53:48 发布
最新推荐文章于 2024-09-14 21:53:48 发布
阅读量271 收藏 9
点赞数 3
文章标签： 链表 学习 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuziNO_1/article/details/140619639
版权

双向链表

1.1概念

1> 所谓双向链表，就是从任意一个节点既能存储其前驱节点信息也能存储后继节点信息

2> 节点结构体中增加一个指向前驱节点的指针

struct Node
{
    union 
    {
      int len;            //头结点数据域
      datatype data;       //普通节点数据域      
    };
    struct Node * prio;            //指向前驱节点的指针
    struct Node * next;            //指向后继节点的指针
};

3> 头结点没有前驱，最后一个节点没有后继

1.2创建双向链表

1> 参数：不需要，只需要从堆区申请出一个头结点大小的空间，就创建了一个双向链表

2> 返回值：返回堆区空间中头结点的地址即可

3> 注意：需要将头结点数据域初始化为0，两个指针域分别初始化为NULL

//创建双向链表
NodePtr list_create()
{
    //在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)   //if(L = NULL)
    {
        printf("创建失败\n");
        return NULL;
    }

    //说明链表创建成功
    L->len = 0;           //链表长度为0
    L->prio = NULL;       //前驱指针为空
    L->next = NULL;        //后继指针为空

    printf("创建成功\n");
    return L;
}

1.3 判空

//链表判空
int list_empty(NodePtr L)
{
    return L->next == NULL;
}

1.4 申请节点封装数据

//申请节点封装数据
NodePtr apply_node(datatype e)
{
    //申请节点空间的大小
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("节点申请失败\n");
        return NULL;
    }

    //给节点赋值
    p->data = e;
    p->prio = NULL;
    p->next = NULL;

    return p;
}

1.5 头插

1> 参数：链表、要插入的元素

2> 返回值：int

3> 注意：对于空链表和非空链表的插入，有所不同，并且不能合并

//链表头插
int list_insert_head(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL == L)
    {
        printf("插入失败\n");
        return -1;
    }

    //申请节点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }

    //头插逻辑
    if(list_empty(L))
    {   //链表为空时的插入逻辑
        p->prio = L;
        L->next = p;
    }else
    {
        //链表非空时的插入
        p->prio = L;
        p->next = L->next;
        L->next->prio = p;  //p->next->prio=p;
        L->next = p;
    }

    printf("插入成功\n");
    
    L->len++;     //链表长度变化

    return 0;
}

1.6 链表遍历

1> 参数：链表

2> 返回值：int

3> 注意：需要使用一个遍历指针，从第一个节点出发，到最后一个节点

//链表遍历
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }

    //遍历逻辑
    NodePtr q = L->next;  //从第一个节点出发
    while(q)
    {
        //输出数据域
        printf("%c\t", q->data);

        //遍历指针后移
        q = q->next;
    }
    printf("\n");

}

1.7 按位置查找节点

1> 参数：链表、要查找的位置

2> 返回值：成功返回找到的结点，失败返回NULL

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L)||pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //查找逻辑
    NodePtr q = L;   //定义遍历指针从头结点出发
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    //返回节点
    return q;

}

1.8 任意位置删除

1> 参数：链表、要删除的位置

2> 返回值:int

3> 注意：对于双向链表的任意位置进行操作时（插入、删除），可以找到前驱结点处理也可以不用找到前驱结点

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    
    //找到要删除的节点
    NodePtr q = list_search_pos(L, pos);
    
    //删除逻辑
    if(q->next == NULL)
    {
        //表示q为最后一个节点
        q->prio->next = NULL;

    }else
    {
        //上传下达
        q->prio->next = q->next;
        q->next->prio = q->prio;
    }

    free(q);    //释放自己
    q = NULL;


    printf("删除成功\n");
    //表长变化
    L->len--;

    return 0;

}

1.9 销毁链表

1> 参数：链表

2> 返回值：int

3> 注意：需要将所有的节点，全部删除后，然后删除头结点

//链表删除
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("删除失败\n");
        return;
    }
    
    //删除所有节点
    while(!list_empty(L))
    {
        list_delete_pos(L, 1);
    }
    

    //删除头结点
    free(L);
    L = NULL;

    printf("链表释放成功\n");
    
}

1.10 代码汇总

1> doublelinklist.h

#ifndef DOUBLELINKLIST_H
#define DOUBLELINKLIST_H
#include<myhead.h>

typedef char datatype;   //数据域的类型

//定义节点类型
typedef struct Node
{
    union
    {
        int len;       //头节点数据域
        datatype data;  //普通节点数据域
    };

    struct Node *prio;  //前驱指针
    struct Node *next;  //后继指针
}Node, *NodePtr;

//创建双向链表
NodePtr list_create();

//链表判空
int list_empty(NodePtr L);

//申请节点封装数据
NodePtr apply_node(datatype e);

//链表头插
int list_insert_head(NodePtr L, datatype e);

//链表遍历
int list_show(NodePtr L);

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L, int pos);

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos);

//链表删除
void list_destroy(NodePtr L);


#endif

2> doublelinklist.c

#include"doublelinklist.h"

//创建双向链表
NodePtr list_create()
{
    //在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)   //if(L = NULL)
    {
        printf("创建失败\n");
        return NULL;
    }

    //说明链表创建成功
    L->len = 0;           //链表长度为0
    L->prio = NULL;       //前驱指针为空
    L->next = NULL;        //后继指针为空

    printf("创建成功\n");
    return L;
}

//链表判空
int list_empty(NodePtr L)
{
    return L->next == NULL;
}

//申请节点封装数据
NodePtr apply_node(datatype e)
{
    //申请节点空间的大小
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("节点申请失败\n");
        return NULL;
    }

    //给节点赋值
    p->data = e;
    p->prio = NULL;
    p->next = NULL;

    return p;
}

//链表头插
int list_insert_head(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL == L)
    {
        printf("插入失败\n");
        return -1;
    }

    //申请节点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }

    //头插逻辑
    if(list_empty(L))
    {   //链表为空时的插入逻辑
        p->prio = L;
        L->next = p;
    }else
    {
        //链表非空时的插入
        p->prio = L;
        p->next = L->next;
        L->next->prio = p;  //p->next->prio=p;
        L->next = p;
    }

    printf("插入成功\n");
    
    L->len++;     //链表长度变化

    return 0;
}

//链表遍历
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }

    //遍历逻辑
    NodePtr q = L->next;  //从第一个节点出发
    while(q)
    {
        //输出数据域
        printf("%c\t", q->data);

        //遍历指针后移
        q = q->next;
    }
    printf("\n");

}

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L)||pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //查找逻辑
    NodePtr q = L;   //定义遍历指针从头结点出发
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    //返回节点
    return q;

}

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    
    //找到要删除的节点
    NodePtr q = list_search_pos(L, pos);
    
    //删除逻辑
    if(q->next == NULL)
    {
        //表示q为最后一个节点
        q->prio->next = NULL;

    }else
    {
        //上传下达
        q->prio->next = q->next;
        q->next->prio = q->prio;
    }

    free(q);    //释放自己
    q = NULL;


    printf("删除成功\n");
    //表长变化
    L->len--;

    return 0;

}

//链表删除
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("删除失败\n");
        return;
    }
    
    //删除所有节点
    while(!list_empty(L))
    {
        list_delete_pos(L, 1);
    }
    

    //删除头结点
    free(L);
    L = NULL;

    printf("链表释放成功\n");
    
}

3> main.c

#include"doublelinklist.h"

int main(int argc, const char *argv[])
{
    //调用创建函数
    NodePtr L = list_create();
    if(NULL == L)
    {
        return -1;
    }

    //调用头插函数
    list_insert_head(L, 'Q');
    list_insert_head(L, 'W');
    list_insert_head(L, 'E');
    list_insert_head(L, 'R');
    list_insert_head(L, 'D');
    list_insert_head(L, 'F');

    //调用遍历函数
    list_show(L);

    //调用任意位置删除函数
    list_delete_pos(L, 1);
    list_delete_pos(L, 3);
    list_delete_pos(L, L->len);

    list_show(L);

    //释放链表
    list_destroy(L);
    L = NULL;

    list_show(L);
    
    
    return 0;
}

循环链表

2.1 概念

1> 循环链表，就是首尾相接的链表。

2> 单向循环链表：只需要将最后一个节点的指针域指向头结点即可

3> 双向循环链表：需要将最后一个阶段的指针域指向头结点，头结点的前驱指针指向最后一个阶段

2.2 单向链表操作

1> 节点结构体

//定义数据类型
typedef int datatype;

//定义结点类型
typedef struct Node
{
    union
    {
        int len;    //头结点数据域
        datatype data;  //普通结点数据域
    };

    struct Node *next;   //指针域
};

2> 链表的创建

注意：创建头结点后，需要将头结点的指针域指向头结点自身

//创建循环链表
NodePtr list_create()
{
    //在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }

    //初始化
    L->len = 0;
    L->next = L;       //头结点指针域指向自己

    printf("创建成功\n");
    return L;
}

3> 链表判空

//链表判空
int list_empty(NodePtr L)
{
    return L->next == L;
}

4> 申请节点封装数据

//链表申请空间封装节点
NodePtr apply_node(datatype e)
{
    //堆区申请一个节点的空间
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("申请失败\n");
        return NULL;
    }

    //给节点赋值
    p->data = e;
    p->next = NULL;

    return p;
}

5> 按位置查找节点

//按位置进行查找
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //查找逻辑
    NodePtr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    return q;
}

6> 尾插

//链表尾插
int list_insert_tail(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL == L)
    {
        printf("插入失败\n");
        return -1;
    }
    
    //找到最后一个节点
    NodePtr q = list_search_pos(L, L->len);
    
    //封装节点
    NodePtr p = apply_node(e);
    if(NULL == p)
    {
        return -1;
    }
    
    //插入逻辑
    p->next = q->next;
    q->next = p;
    
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;

}

7> 链表遍历

//链表遍历
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }

    //遍历逻辑
    NodePtr q = L->next;
    while(q != L)
    {
        printf("%c\t", q->data);
        q = q->next;        //继续访问下一个
    }
    printf("\n");

}

8> 头删

//链表的头删
int list_delete_head(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    
    //头删逻辑
    NodePtr p = L->next;    //标记
    L->next = p->next;      //孤立
    free(p);                //删除
    p = NULL;

    
    //表长变化
    L->len--;
    printf("删除成功\n");
    return 0;
}

9> 销毁链表

//链表销毁
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL == L)
    {
        printf("释放失败\n");
        return ;
    }
    
    //删除节点
    while(!list_empty(L))
    {
        list_delete_head(L);
    }
    
    //释放头结点
    free(L);
    L = NULL;
    printf("销毁成功\n");
}

作业：

1> 将双向链表和循环链表自己实现一遍，至少要实现创建、增、删、改、查、销毁工作

2> 使用循环链表完成约瑟夫环问题

joseph.c
#include"joseph.h"

//创建循环列表
NodePtr list_create()
{
    NodePtr L=(NodePtr)malloc(sizeof(Node));
    if(NULL==L)
    {
        printf("创建失败\n");
        return NULL;
    }
    L->len=0;
    L->next=L;
    printf("创建成功\n");
    return L;
}

//判空
int list_empty(NodePtr L)
{
    return L==L->next->next;
}

//链表申请空间封装节点
NodePtr apply_node(datatype e)
{
    NodePtr p=(NodePtr)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("申请失败\n");
        return NULL;
    }
    p->data=e;
    p->next=NULL;
    return p;
}

//按值查找前驱节点
NodePtr list_search_value(NodePtr L,datatype e)
{
    if(NULL==L||list_empty(L))
    {
        printf("查找失败\n");
        return NULL;
    }
    NodePtr q=L;
    for(int i=0;i<L->len;i++)
    {
        if(q->next->data==e)
        {
            printf("找到了\n");
            return q;
        }
        q=q->next;
    }
    return NULL;
}


//按值删除
int list_delete_value(NodePtr L,datatype e)
{
    if(NULL==L||list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    //找到前驱节点
    NodePtr q=list_search_value(L,e);
    q->next=q->next->next;
    L->len--;
    printf("删除成功\n");
    return 0;
}

//按位置查找
NodePtr list_search_pos(NodePtr L,int pos)
{
    if(L==NULL||pos<0||pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }
    NodePtr q=L;
    for(int i=0;i<pos;i++)
    {
        q=q->next;
    }
    return q;
}

//尾插
int list_insert_tail(NodePtr L,datatype e)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("插入失败\n");
        return -1;
    }
    //找到最后节点
    NodePtr q=list_search_pos(L,L->len);
    //封装节点
    NodePtr p=apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
    //插入逻辑
    p->next=q->next;
    q->next=p;
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

//遍历函数
int  list_show(NodePtr L)
{
    if(NULL==L)
    {
        printf("遍历失败\n");
        return -1;
    }
    NodePtr H=L->next;
    for(int i=0;i<L->len;i++)
    {
        printf("%d\t",H->data);
        H=H->next;
    }
    printf("遍历完成\n");
    return 0;
}


//main.c
#include"joseph.h"

int main()
{
    NodePtr L=list_create();
    if(NULL==L)
    {
        return -1;
    }
    printf("请输入参加人数和死亡代码:");
    int sum=0,num=0;
    scanf("%d %d",&sum,&num);
    for(int i=0;i<sum;i++)
    {
        list_insert_tail(L,i+1);   
    }
    NodePtr q=L;
    while(q->next!=L)
    {
        q=q->next;
    }
    list_show(L);
    while(!list_empty(L))
    {
        for(int i=1;i<=num;i++)
        {
            if(q->next==L)
            {
                q=q->next;
            }
            q=q->next;
        }
        
        list_delete_value(L,q->data);
        list_show(L);

    }
    return 0;
}

//joseph.h
#ifndef JOSEPH_H
#define JOSEPH_H
#include<myhead.h>

//定义数据类型
typedef int datatype;

typedef struct Node
{
    union
    {
        int len;//头结点数据域
        datatype data;//普通指针数据域
    };
    struct Node *next;//指针域
}Node,*NodePtr;

//创建循环列表
NodePtr list_create();

//判空
int list_empty(NodePtr L);

//链表申请空间封装节点
NodePtr apply_node(datatype e);

//按位置查找
NodePtr list_search_pos(NodePtr L,int pos);

//尾插
int list_insert_tail(NodePtr L,datatype e);

//链表遍历
int list_show(NodePtr L);

//按值删除
int list_delete_value(NodePtr L,datatype e);

//按值查找前驱节点
NodePtr list_search_value(NodePtr L,datatype e);

#endif

wuziNO_1
关注
易语言-易语言链表学习
06-29
在这个“易语言-易语言链表学习”资源中，我们将探讨链表的基础知识，以及它在链队列和链堆栈中的应用。 首先，链表是由一系列节点组成的数据结构，每个节点包含数据部分和指针部分，指针指向下一个节点。这使得...
Linux 内核通用链表学习小结
01-11
在linux内核中封装了一个通用的双向链表库，这个通用的链表库有很好的扩展性和封装性，它给我们提供了一个固定的指针域结构体，我们在使用的时候，只需要在我们定义的数据域结构体中包含这个指针域结构体就可以了，...
链表学习总结
weixin_53700782的博客
01-04 2227
链表学习总结
链表学习
Timoqian的博客
03-20 289
链表的定义 链表的遍历
链表学习-小白也能学会的链表
2202_75468818的博客
11-27 1047
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
链表的学习
qq_54593609的博客
07-16 940
链表的学习
C#链表学习与使用
weixin_44171249的博客
08-01 3779
学习链表
剑指offer-链表学习笔记
qq_44653420的博客
05-01 723
剑指offer-链表学习笔记 一、链表概述  链表是一种动态的数据结构，在创建链表时，无需知道链表的长度，当插入一个节点时，我们只需要为新的节点分配内存，然后调整指针的指向来确保新节点被连接到链表中。内存分配不是在创建链表时一次性完成的，而是每添加一个节点分配一次内存。由于没有闲置的内存，链表的空间效率比数组高。链表节点定义如下： struct ListNode { int m_nValue; ListNode* m_pNext; }; 向链表中插入一个节点： void AddToTai
c++链表学习——指针
Enzyme_Dinosaur的博客
03-13 2012
#include <iostream> #include <cstring> using namespace std; struct link { int elem; struct link* next; }; // link* initLink();//初始化 link* insertElem(link* p, int elem, int add);//插入 link* delElem(link* p, int add);//删 int selectElem(link* p,
数据结构：链表学习
newbordwly的博客
01-22 831
链表是一种线性数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。链表的节点在内存中不是顺序存储的，而是通过指针链接在一起。链表的主要优点是插入、删除操作方便，不需要大量移动元素。队列是一种先进先出（FIFO）的数据结构，也可以用链表来实现。栈是一种后进先出（LIFO）的数据结构，可以用链表来实现。
数据结构双向链表学习
fengjuju的博客
05-02 1292
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
freeRTOS链表学习笔记
u013610102的博客
03-26 1863
freeRTOS链表学习笔记 链表是RTOS的核心之一，链表的作用主要服务于RTOS的任务之间的调度。任务的唤醒和休眠、任务的调度等都基于链表实现。阅读了freeRTOS链表的源码后，决定梳理一遍链表相关的源码，用于加深对链表的理解。其中对源码进行了一些删减，方便理解理解和阅读。文中的代码重新书写了一遍，可能和源码有些不一样。 1 头文件 头文件其中只涉及3个结构体，其中struct xMiniLIST_ITEM 是struct xLIST_ITEM 的简化版，则实际上只涉及2个结构体。 str
C语言链表学习教案.pptx
09-30
C语言链表学习教案.pptx
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 827
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
计算几何学习
网安小白
09-12 436
学习计算几何过程中对经典算法的记录
看Threejs好玩示例，学习创新与技术(二)
最新发布
htsitr2的专栏
09-14 343
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
09-11 908
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
【学习笔记】SSL密码套件之哈希
Taki_UP的博客
09-12 1123
本篇介绍了TLS/SSL密码套件中常用的哈希算法，包括Poly1305、SHA384、SHA256、SHA、MD5
C语言链表学习：创建、遍历与操作
"这是一份关于C语言实现链表的学习资料，涵盖了链表的基本原理、数据结构定义以及一系列操作链表的方法，包括创建、遍历、插入、查找、修改、删除和内存回收等。" 在计算机科学中，链表是一种线性数据结构，与数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值