C 数据结构 之 链表

最新推荐文章于 2022-02-22 16:57:55 发布
最新推荐文章于 2022-02-22 16:57:55 发布
阅读量164 收藏
点赞数 1
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaiderzhu1314/article/details/107943692
版权

链表

  • 1. 概念
    • 用来管理 线性链式物理结构 功能的数据结构，以后在程序中使用线性链式物理结构就不需要写代码操作存储区了，直接使用链表提供的各种功能就可以啦。
  • 2. 实现方法
typedef struct node
{
    int val;             // 记录数字的成员变量
    struct node *p_prev; // 指向前一个节点的指针成员变量
    struct node *p_next; // 指向后一个节点的指针成员变量
} node;

typedef struct
{
    node head;   // 头结点
    node tail;   // 尾节点
    node *p_cur;  // 记录遍历过程中上一个操作的节点 
} link;

link_1.h

#ifndef            __LINK_1_H__
#define            __LINK_1_H__
typedef struct node
{
    int val;             // 记录数字的成员变量
    struct node *p_prev; // 指向前一个节点的指针成员变量
    struct node *p_next; // 指向后一个节点的指针成员变量
} node;

typedef struct
{
    node head;   // 头结点
    node tail;   // 尾节点
    node *p_cur;  // 记录遍历过程中上一个操作的节点 
} link;

// 链表初始化函数
void link_init(link *);

// 链表清理函数
void link_deinit(link *);

// 获得数字个数的函数
int link_size(const link *);

// 判断链表是否为空的函数
int link_empty(const link *);

// 在链表的最前面插入数字
int link_add_head(link *, int);

//在链表末尾追加新数字的函数
int link_append(link *, int);

// 按照从小到大的顺序在链表中间插入新的数字的函数
int link_insert(link *, int);

//删除最前面的数字的函数
int link_remove_head(link *);

// 删除最后一个有效数字的函数
int link_remove_tail(link *);

// 删除链表中间指定数字的节点
int link_remove(link *, int);

// 获得最前面的数字
int link_get_head(const link *, int *);

// 获得链表里最后一个数字的函数
int link_get_tail(const link *, int *);

// 根据编号获得数字的函数
int link_get(const link *, int *, int);

// 开始从前向后遍历链表的函数
void link_begin(link *);

// 从前向后遍历的过程中获得下一个数字的函数
int link_next(link *, int *);

// 开始从后向前遍历链表的函数
void link_rbegin(link *);

// 从后向前遍历过程中获得下一个数字的函数
int link_prev(link *, int *);

#endif      //__ LINK_1_H__

link_1.c

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

// 链表初始化函数
void link_init(link *p_link) {
    p_link->head.p_next = &p_link->tail; // 把头结点和尾节点连接起来形成一个空的链式物理结构
    p_link->tail.p_prev = &p_link->head; // 尾节点向前指向头节点
    p_link->tail.p_next = NULL; // 把尾节点里的指针设置成空指针
    p_link->head.p_prev = NULL; // 把头节点里指向前一个节点的指针设置成空指针
    p_link->p_cur = NULL;
    // 遍历过程是对节点处理顺序是有要求的, 因为p_cur是记录遍历过程中上一个操作的节点, 修改链表的函数都有可能破坏链表的遍历过程
    // 所以规定在遍历过程中不可以有修改链表结构的操作, 这里规定了两个状态, 遍历状态和非遍历状态
    // 刚初始化完一个链表后, 它应该处于非遍历状态, 即 p_cur 是空指针的时候,表示这个链表没有处于遍历过程. 想让链表结束遍历过程的时候就把 p_cur 设置为空指针
    // 所以规定只要做了修改链表结构的操作, 就立刻结束遍历过程, 通过这样方式,可以保证在遍历过程中链表的结构是不会被修改的
}

// 链表清理函数
void link_deinit(link *p_link) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    p_link->p_cur = NULL;

    // 每次循环把最前面的有效节点删除，并释放
    while (p_link->head.p_next != &p_link->tail) { // 头结点后面不是尾节点，就说明存在有效节点，循环继续
        p_first = &p_link->head;
        p_mid = p_first->p_next;
        p_last = p_mid->p_next;
        // 把p_mid指向的节点从链式物理结构中摘除
        p_first->p_next = p_last;
        p_last->p_prev = p_first;
        // 释放p_mid指针指向的节点
        free(p_mid);
        p_mid = NULL;
    }
}

// 获得数字个数的函数
int link_size(const link *p_link) {
    int cnt = 0;
    // 不写const 说明可以通过p_tmp改变链表，会与形参矛盾,编译警告
    const node *p_tmp = NULL;
    for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
        const node *p_first = p_tmp;
        const node *p_mid = p_first->p_next;
        const node *p_last = p_mid->p_next;
        if (p_mid != &p_link->tail) { // 当p_mid指针不是指向尾节点就一定指向一个有效节点
            cnt++;
        }
    }
    return cnt;
}

// 判断链表是否为空的函数
int link_empty(const link *p_link) {
    return p_link->head.p_next == &p_link->tail;
}

// 在链表的最前面插入数字
int link_add_head(link *p_link, int val) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    node *p_node = NULL;
    p_link->p_cur = NULL; // 结束遍历过程
    p_node = (node *)malloc(sizeof(node)); // 动态分配内存用来记录新数字
    if (!p_node) {
        // 动态内存分配失败
        return 0;
    }
    p_node->val = val;
    p_node->p_next = NULL; // 不写也行,好习惯
    p_node->p_prev = NULL; 
    // 把三个节点指针指向链表最前面的三个节点
    p_first = &p_link->head;
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    // 把新节点插入到p_first 和 p_mid中间
    p_first->p_next = p_node;
    p_node->p_next = p_mid;
    p_mid->p_prev = p_node;
    p_node->p_prev = p_first;
    return 1;
}

// //在链表末尾追加新数字的函数
// int link_append(link *p_link, int val) {
//     node *p_tmp = NULL;
//     node *p_node = NULL;
//     p_link->p_cur = NULL;    // 结束遍历过程
//     p_node = (node *)malloc(sizeof(node)); // 动态分配内存用来记录新数字
//     if (!p_node) {
//         // 动态内存分配失败
//         return 0;
//     }
//     p_node->val = val;
//     p_node->p_next = NULL; // 不写也行,好习惯
//     p_node->p_prev = NULL;
//     // 编写for循环找到链表末尾的位置
//     for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
//         node *p_first = p_tmp;
//         node *p_mid = p_first->p_next;
//         node *p_last = p_mid->p_next;
//         if (p_mid == &p_link->tail) { // 当p_mid 指向尾节点,p_first 和 p_mid 指针中间的位置就是要插的位置
//             p_first->p_next = p_node;
//             p_node->p_next = p_mid;
//             p_mid->p_prev = p_node;
//             p_node->p_prev = p_first;
//             break;
//         }                       
//     }
//     return 1;
// }

//在链表末尾追加新数字的函数
int link_append(link *p_link, int val) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    node *p_node = NULL;
    p_link->p_cur = NULL;   // 结束遍历过程
    p_node = (node *)malloc(sizeof(node)); 
    if (!p_node) {
        return 0;
    }
    p_node->val = val;
    p_node->p_next = NULL;
    p_node->p_prev = NULL;

    p_first = p_link->tail.p_prev;  // p_first 指针指向尾节点前面的节点
    p_mid = p_first->p_next;        // p_mid 指针指向尾节点
    p_last = p_mid->p_next;
    // 把新节点插入到p_first 和 p_mid 之间
    p_first->p_next = p_node;
    p_node->p_next = p_mid;
    p_mid->p_prev = p_node;
    p_node->p_prev = p_first;
    return 1;
}

// 按照从小到大的顺序在链表中间插入新的数字的函数
int link_insert(link *p_link, int val) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    node *p_tmp = NULL;
    node *p_node = NULL;
    p_link->p_cur = NULL;
    p_node = (node *)malloc(sizeof(node));
    if (!p_node) {
        return 0;
    }
    p_node->val = val;
    p_node->p_next = NULL;
    p_node->p_prev = NULL;
    // for循环寻找插入位置
    for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
        node *p_first = p_tmp;
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
    // 两种情况
    // 1. p_mid 指针指向节点里的数字比要插入的数字大, 2. 所有节点的数字都没有要插入的大,直至for循环到p_mid 指向尾节点
        if (p_mid->val > val || p_mid == &p_link->tail) {
            p_first->p_next = p_node;
            p_node->p_next = p_mid;
            p_mid->p_prev = p_node;
            p_node->p_prev = p_first;
            break;
        }
    }
    return 1;
}

//删除最前面的数字的函数
int link_remove_head(link *p_link) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    p_link->p_cur = NULL;   // 结束遍历过程
    if (p_link->head.p_next == &p_link->tail) {
        // 链表是空的情况下无法删除任何节点
        return 0;
    }
    // 让三个指针指向链表最前面的三个节点
    p_first = &p_link->head;
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    // 把p_mid指向的节点从链式物理结构中摘出来
    p_first->p_next = p_last;
    p_last->p_prev = p_first;
    free(p_mid);
    p_mid = NULL;
    return 1;
}

// // 删除最后一个有效数字的函数
// int link_remove_tail(link *p_link) {
//     node *p_tmp = NULL;
//     p_link->p_cur = NULL; //结束遍历过程
//     //for循环找到最后一个有效数字所在的节点
//     for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
//         node *p_first = p_tmp;
//         node *p_mid = p_first->p_next;
//         node *p_last = p_mid->p_next;
//         // 当p_last指针指向尾节点,p_mid指针一定指向最后一个有效节点
//         if (p_last == &p_link->tail) {
//             // 把p_mid指针指向的节点从链式物理结构中摘出来
//             p_first->p_next = p_last;
//             p_last->p_prev = p_first;
//             free(p_mid);
//             p_mid = NULL;
//             return 1;
//         }
//     }
//     return 0;
// }

// 删除最后一个有效数字的函数
int link_remove_tail(link *p_link) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    p_link->p_cur = NULL;
    if (p_link->head.p_next == &p_link->tail) {
        // 链表为空
        return 0;
    }
    p_last = &p_link->tail;    // p_last只想最后一个有效节点
    p_mid = p_last->p_prev;    //p_mid 指针只想最后一个有效节点
    p_first = p_mid->p_prev;
    // 把p_mid从最后一个有效节点里摘除掉
    p_first->p_next = p_last;
    p_last->p_prev = p_first;
    //释放p_mid 指针指向的节点
    free(p_mid);
    p_mid = NULL;
    return 1;
}

// 删除链表中间指定数字的节点
int link_remove(link *p_link, int val) {
    node *p_tmp = NULL;
    p_link->p_cur = NULL;
    // 编写for循环找到要删除的数字所在节点
    for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
        node *p_first = p_tmp;
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
        // 这里要防止有效节点里没有指定数字而尾节点里有的情况
        if (p_mid->val == val && p_mid != &p_link->tail)
        {
            p_first->p_next = p_last;
            p_last->p_prev = p_first;
            free(p_mid);
            p_mid = NULL;
            return 1;
        }
    }
    return 0;
}

// 获得最前面的数字
int link_get_head(const link *p_link, int *p_val) {
    const node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    if (p_link->head.p_next ==  &p_link->tail) {
        return 0;
    }
    p_first = &p_link->head;
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    // 把p_mid指针指向节点里的数字传递给调用函数
    *p_val = p_mid->val;
}

// // 获得链表里最后一个数字的函数
// int link_get_tail(const link *p_link, int *p_val) {
//     const node *p_tmp =NULL;
//     for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
//         const node *p_first = p_tmp;
//         const node *p_mid = p_first->p_next;
//         const node *p_last = p_mid->p_next;
//         if (p_last == &p_link->tail) {
//             *p_val = p_mid->val;
//             return 1;
//         }
//     }
//     return 0;
// }

// 获得链表里最后一个数字的函数
int link_get_tail(const link *p_link, int *p_val) {
    const node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    if (p_link->head.p_next == &p_link->tail) {
        // 链表为空
        return 0;
    }
    p_last = &p_link->tail;
    p_mid = p_last->p_prev;
    p_first = p_mid->p_prev;

    *p_val = p_mid->val; //把p_mid指针指向的节点里的数字传递给调用函数
    return 1;
}

// 根据编号获得数字的函数
int link_get(const link *p_link, int *p_val, int sn) {
    int cnt = 0;
    const node *p_tmp = NULL;
    //for 循环找指定节点
    for (p_tmp = &p_link->head; p_tmp != &p_link->tail; p_tmp = p_tmp->p_next) {
        
        const node *p_first = p_tmp;
        const node *p_mid = p_first->p_next;
        const node *p_last = p_mid->p_next;
        // 确保p_mid指针是有效节点而不是指向尾节点
        if (p_mid != &p_link->tail && cnt == sn) {
            *p_val = p_mid->val;
            return 1;
        }
        cnt++;
    }
    return 0;
}

// 开始从前向后遍历链表的函数
void link_begin(link *p_link) {
    p_link->p_cur = &p_link->head; // 把头节点设置为上一个操作的节点
}

// 从前向后遍历的过程中获得下一个数字的函数
int link_next(link *p_link, int *p_val) {
    // 如果没有调用 link_begin 函数, 是没有办法开始遍历过程的
    if (!p_link->p_cur) {
        // 链表没有处于遍历过程中
        return 0;
    }
    p_link->p_cur = p_link->p_cur->p_next; //找到这次要操作的节点并记录下来
    if (p_link->p_cur == &p_link->tail) {
        // 这次要操作的节点是尾节点就说明遍历过程已经结束了
        p_link->p_cur = NULL; // 结束遍历
        return 0;
    }
    else {
        *p_val = p_link->p_cur->val; //把这次要操作的节点内容传递给调用函数
        return 1; 
    }
    
}

// 开始从后向前遍历链表的函数
void link_rbegin(link *p_link) {
    p_link->p_cur = &p_link->tail; //把尾节点节点设置为上一个操作的节点
}

// 从后向前遍历过程中获得下一个数字的函数
int link_prev(link *p_link, int *p_val) {
    // 如果没有调用 link_rbegin 函数, 是没有办法开始遍历过程的
    if (!p_link->p_cur) {
        return 0;
    }
    p_link->p_cur = p_link->p_cur->p_prev;
    if (p_link->p_cur == &p_link->head) {
        // 这次要操作的节点是头节点就说明遍历已经结束
        p_link->p_cur = NULL;
        return 0;
    }
    else {
        *p_val = p_link->p_cur->val;
        return 1;
    }
}

link_main.c

#include <stdio.h>
#include "link_1.h"
int main() {
    int val = 0, size = 0;
    link lnk = {0};
    link_init(&lnk);
    link_add_head(&lnk, 50);
    link_add_head(&lnk, 10);
    link_append(&lnk, 70);
    link_append(&lnk, 100);
    link_insert(&lnk, 30);
    link_insert(&lnk, 20);
    link_insert(&lnk, 40);
    link_insert(&lnk, 80);
    link_insert(&lnk, 60);
    link_insert(&lnk, 90);
    link_remove_head(&lnk);
    link_remove_tail(&lnk);
    link_remove(&lnk, 40);

    link_get_head(&lnk, &val);
    printf("最前面的数字是%d\n", val);
    link_get_tail(&lnk, &val);
    printf("最后面的数字是%d\n", val);
    
    size = link_size(&lnk);
    for (int num = 0; num < size; num++) {
        link_get(&lnk, &val, num);
        printf("%d ", val);
    }
    printf("\n");

    // 正向遍历
    link_begin(&lnk);
    while(1) {
        if (!link_next(&lnk, &val)) {
            break;
        } 
        printf("%d ", val);
    }
    printf("\n");

    // 反向遍历
    link_rbegin(&lnk);
    while(1){
        if (!link_prev(&lnk, &val)) {
            break;
        }
        printf("%d ", val);
    }
    printf("\n");

    link_deinit(&lnk);
    return 0;
}

moonx@moonx: $ gcc link_1.c link_main.c; ./a.out 
最前面的数字是20
最后面的数字是90
20 30 50 60 70 80 90 
20 30 50 60 70 80 90 
90 80 70 60 50 30 20
半只因
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 数据结构之链表实现代码
01-20
最近在复习数据结构的相关知识，感觉在初学的时候还是有很多东西没有掌握，不过现在终于算是搞得比较有头绪了，所以就在写出来和大家一起分享！ 什么是链表 简单的说，链表就是由多个结点离散分配，彼此通过指针...
数据结构——分块查找
yyy_zxc的博客
06-22 511
“索引表”中有序的保存每个分块的最大关键字和分块的存储空间
Linux C编程3-文件属性
qq_37932504的博客
06-24 1375
文件属性应用编程
Linux下link函数的使用
judgejames的博客
11-04 7239
一、头文件 #include&lt;unistd.h&gt; 二、函数原型 int link(const char *oldname, const char *newname); 三、函数介绍                  在UNIX系统中，一个文件可能同时拥有多个文件名。也就是说多个不同名字的文件在文件系统中可能是同一个文件。当我们要复制一个文件时，并不是真正复制文件内容，只...
C的数据结构---带头结点的单链表
LoveHoneyYou的博客
02-22 1005
补充知识： 结构体中嵌套结构体： 1.结构体中可以嵌套另一个结构体类型的数据 ⒉结构体中可以嵌套指向自身的指针和指向另一个结构体的指针 3.结构体中不能嵌套自己类型的数据（无穷递归，确定不了数据类型的内存大小，分配不了内存） 链表： 链表是一种物理存储单元上非连续的存储结构，由一系列（链表中每一个元素称为结点）组成，结点可以在运行时动态生成，结点与结点之间通过指针链接。每个结点包括两部分: 一部分是存储数据元素的数据域，另一部分是存储下一个结点地址的指针域 1）. 链表是一种常用的数据结构
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
C语言数据结构之循环链表的简单实例
12-26
C语言数据结构之循环链表的简单实例 实例代码： # include # include typedef struct node //定义链表中结点的结构 { int code; struct node *next; }NODE,*LinkList; /*错误信息输出函数*/ void Error(char *...
C语言数据结构实现链表去重的实例
01-20
C语言数据结构实现链表去重的实例 题目及分析 链表去重 时间限制 300 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 给定一个带整数键值的单链表L，本题要求你编写程序，删除那些键值的绝对值有...
C++ 链表实现
Jach_huhu
10-11 229
#include #include //#include using namespace std; typedef int DataType; typedef struct node { DataType data; node *next; }linkNode; //链表初始化 /**初始化链表头部指针需要用二级指针或者一级指针的引用**/ voi
数据结构(c语言实现)——单链表
weixin_43275549的博客
07-16 1101
单链表数据结构定义 typedef struct LNode { People data; //结点的数据域 struct LNode* next; //结点的指针域 } LNode, *LinkList; //LinkList为指向结构体LNode的指针类型，这里Linklist 与LNote*等价 单链表 头插操作 这里修改指针的时候一定要先将新节点指针指向原链表第一个元素，然后修改头节点。 如果是先将头节点指向新节点，原来链表中元素会丢失 后面插入操作也是先将新节点指针指向插入点后元.
链表基础知识总结
热门推荐
u012531536的专栏
05-02 17万+
链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据，但又各有各的特点。数组的优势，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但是，这种时间上的便利性，是因为数组在内存中占用了连续的空间，在进行类似的查找或者遍历时，本质是指针在内存中的定向偏移。然而，当...
C语言数据结构--双向链表的实现
figting
08-28 407
C语言数据结构–双向链表的实现 双向链表对比单向链表增加了一个指向前一个节点的指针。 双向链表和单向链表节点的对比： 1、单向链表的节点 //节点 typedef struct node{ int val; struct node* p_next; }node_t; //链表的结构体 typedef struct{ //头节点 node_t head; //尾节点 node_t tail; }link_t; 2 、
数据结构-C语言实现链表
lijiedebiancheng的博客
11-15 5030
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define TURE 1 #define FALSE -1 typedef int Status; typedef int Elemtype; typedef struct Node{ Elemtype data; struct Node *next; }Node,*...
链表
biliguns的博客
03-20 765
链表 链表的基本概念 链表是一种常用的数据结构，它通过指针将一些列数据结点，连接成一个数据链。相对于数组，链表具有更好的动态性（非顺序存储）。 数据域用来存储数据，指针域用于建立与下一个结点的联系。 建立链表时无需预先知道数据总量的，可以随机的分配空间，可以高效的在链表中的任意位置实时插入或删除数据。 链表的开销，主要是访问顺序性和组织链的空间损失。 数组和链表的区别 数组：一次性分配一块...
C语言实现链表数据结构
XIAXU0101的博客
12-16 671
/* ADT 线性表list Data 满足特征的数据，每个元素类型为DataType Opration InitList(L): 初始化操作，建立一个空的线性表 ListEmpty(L): 若线性表为空，返回ture,否则false ClearList(L): 清空线性表 GetElem(L,i,*e):将L中第i个元素返回给e LoacateElem(L,e):在L中查找与e相等元素，返回位置，没有返回0 ListInsert(*L,i,e):在L的第i个元素位置插入e L
C语言简单入门之结构体和链表
maoye的博客
09-12 1万+
C语言的链表也是一个很重要很难啃的骨头，我是这么觉得的！ 以下只是个人对链表的总结和记录方便日后复习所用，如有错误，请留言狠批，谢谢！ 先说下链表的简单实现：  如上图，我们定义一个结构体： 1，2，3，4，5是结构体数据。a，b，c，d，e则是指针变量，在链表中是1.next的表达方式 首先，结构体的名字指向的是链表的首地址（也就是1的地址，而a的存放是2的地址），这样指下去。一个...
图解数据结构：链表（C语言实现）
APlus
10-20 3304
1、链表的定义 链表是由一连串的结构（称为结点）组成的，其中每个节点包含指向链表中下一个结点的指针（除最后一个结点为空指针），其中每个结点可以含有若干个存储数据的数据域。 2、优缺点 相比较于数组，使用链表结构可以克服数组需要预先知道数据大小的缺点，可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。 单链表
【数据结构】单链表的各种功能实现(C语言)
Qingmou's_blog
09-20 4万+
单链表的存储方式
c语言数据结构之链表
最新发布
11-03
链表是一种常见的数据结构，它在计算机科学中有广泛的应用。在C语言中，链表常常用于实现动态内存分配、函数调用栈、多项式运算等问题。单向链表是一种基本的链表结构，它由一系列节点组成，每个节点包含一个数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值