链表编程（C语言）

已于 2022-02-18 22:47:27 修改
阅读量663 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 c语言 数据结构
于 2022-02-17 23:09:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43686863/article/details/122993806
版权

文章目录


在这里插入图片描述

1.带头结点单链表

结点类型描述

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

基本操作定义

LinkList list_init();

void list_head_insert(LinkList L, ElemType e);

void list_tail_insert(LinkList L, ElemType e);

void list_insert(LinkList L, ElemType e, int position);//insert a new node at the nth position

void list_delete(LinkList L, int position);//delete the node of the nth position

void list_modify(LinkList L, ElemType e, int position);//modify the node of the nth position

ElemType list_find(LinkList L, int position);//find the data of the nth position

void list_display(LinkList L);

int list_length(LinkList L);

void list_empty(LinkList L);//wipe data(except head node)

void list_destroy(LinkList *L);//release all the space(include head node)

基本操作实现

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_head_insert(LinkList L, ElemType e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));

    new_node->data = e;
    new_node->next = L->next;
    L->next = new_node;
}

void list_tail_insert(LinkList L, ElemType e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    tail->next = new_node;
    new_node->data = e;
    new_node->next = NULL;
}

void list_insert(LinkList L, ElemType e, int position) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *p = L;

    while (--position) {
        p = p->next;
    }
    new_node->data = e;
    new_node->next = p->next;
    p->next = new_node;
}

void list_delete(LinkList L, int position) {
    LNode *p = L, *q = L->next;

    while (--position) {
        p = p->next;
        q = q->next;
    }
    p->next = q->next;
    free(q);
}

void list_modify(LinkList L, ElemType e, int position) {
    LNode *p = L;

    while (position--) {
        p = p->next;
    }
    p->data = e;
}

ElemType list_find(LinkList L, int position) {
    LNode *p = L;

    while (position--) {
        p = p->next;
    }
    return p->data;
}

void list_display(LinkList L) {
    LNode *p = L->next;

    if (!p) {
        printf("This is a empty single linked list.\n");
    } else {
        printf("All data are: ");
        while (p) {
            printf("%d%c", p->data, (p->next == NULL) ? 46 : 32);
            p = p->next;
        }
        printf("\n");
    }
}

int list_length(LinkList L) {
    LNode *p = L->next;
    int length = 0;

    while (p) {
        length++;
        p = p->next;
    }
    return length;
}

void list_empty(LinkList L) {
    LNode *p;

    while (L->next) {
        p = L->next;
        L->next = p->next;
        free(p);
    }
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

其他操作（交集，差集，合并，逆置，排序）

2.不带头结点单链栈

结点类型描述

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode, *LinkStack;

基本操作定义

LinkStack stack_init();

void stack_push(LinkStack *S, int e);

int stack_pop(LinkStack *S);

void stack_destroy(LinkStack *S);

基本操作实现

LinkStack stack_init() {
    LinkStack S = NULL;
    return S;
}

void stack_push(LinkStack *S, int e) {
    LNode *new_node = (LNode *)malloc(sizeof(LNode));

    new_node->data = e;
    new_node->next = *S;
    *S = new_node;
}

int stack_pop(LinkStack *S) {
    LNode *p = *S;
    int val = p->data;

    *S = p->next;
    free(p);
    return val;
}

void stack_destroy(LinkStack *S) {
    LNode *p = *S;

    while (*S) {
        *S = p->next;
        free(p);
    }
}

3.循环单链表

结点类型描述

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

基本操作定义

LinkList list_init();

void list_head_insert(LinkList L, ElemType e);

void list_tail_insert(LinkList L, ElemType e);

void list_insert(LinkList L, ElemType e, int position);//insert a new node at the nth position

void list_delete(LinkList L, int position);//delete the node of the nth position

void list_modify(LinkList L, ElemType e, int position);//modify the node of the nth position

ElemType list_find(LinkList L, int position);//find the data of the nth position

void list_display(LinkList L);

int list_length(LinkList L);

void list_empty(LinkList L);//wipe data(except head node)

void list_destroy(LinkList *L);//release all the space(include head node)

基本操作实现

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = L;
    return L;
}

void list_head_insert(LinkList L, ElemType e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));

    new_node->data = e;
    new_node->next = L->next;
    L->next = new_node;
}

void list_tail_insert(LinkList L, ElemType e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next != L) {
        tail = tail->next;
    }
    tail->next = new_node;
    new_node->data = e;
    new_node->next = L;
}

void list_insert(LinkList L, ElemType e, int position) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *p = L;

    while (--position) {
        p = p->next;
    }
    new_node->data = e;
    new_node->next = p->next;
    p->next = new_node;
}

void list_delete(LinkList L, int position) {
    LNode *p = L, *q = L->next;

    while (--position) {
        p = p->next;
        q = q->next;
    }
    p->next = q->next;
    free(q);
}

void list_modify(LinkList L, ElemType e, int position) {
    LNode *p = L;

    while (position--) {
        p = p->next;
    }
    p->data = e;
}

ElemType list_find(LinkList L, int position) {
    LNode *p = L;

    while (position--) {
        p = p->next;
    }
    return p->data;
}

void list_display(LinkList L) {
    if (L->next == L) {
        printf("This is a empty circular single linked list.\n");
    } else {
        LNode *p = L->next;

        printf("All data are: ");
        while (p != L) {
            printf("%d%c", p->data, (p->next == L) ? 46 : 32);
            p = p->next;
        }
        printf("\n");
    }
}

int list_length(LinkList L) {
    LNode *p = L->next;
    int length = 0;

    while (p != L) {
        length++;
        p = p->next;
    }
    return length;
}

void list_empty(LinkList L) {
    LNode *p;

    while (L->next != L) {
        p = L->next;
        L->next = p->next;
        free(p);
    }
}

void list_destroy(LinkList *L) {
    LNode *head = (*L)->next, *tmp;

    while (head != *L) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
    free(head);
    *L = NULL;
}

4.循环双链表

结点类型描述

typedef struct DNode {
    ElemType data;
    struct DNode *prior, *next;
} DNode, *DLinkList;

基本操作定义

DLinkList list_init();

void list_insert(DLinkList L, ElemType e, int position);//insert a new node at the nth position

void list_delete(DLinkList L, int position);//delete the node of the nth position

void list_display(DLinkList L);

void list_empty(DLinkList L);//wipe data(except head node)

void list_destroy(DLinkList *L);//release all the space(include head node)

基本操作实现

DLinkList list_init() {
    DLinkList L = (DLinkList) malloc(sizeof(DNode));

    L->data = 0;
    L->next = L;
    L->prior = L;
}

void list_insert(DLinkList L, ElemType e, int position) {
    DNode *new_node = (DNode *)malloc(sizeof(DNode));
    DNode *p = L, *q = L->next;

    while (--position) {
        p = p->next;
        q = q->next;
    }
    new_node->data = e;
    new_node->next = q;
    new_node->prior = p;
    p->next = new_node;
    q->prior = new_node;
}

void list_delete(DLinkList L, int position) {
    DNode *p = L, *q = L->next;

    while (--position) {
        p = p->next;
        q = q->next;
    }
    p->next = q->next;
    q->next->prior = p;
    free(q);
}

void list_display(DLinkList L) {
    if (L->next == L) {
        printf("This is a empty circular double linked list.\n");
    } else {
        DNode *p = L->next;
        printf("All data are: ");
        while (p != L) {
            printf("%d%c", p->data, (p->next == L) ? 46 : 32);
            p = p->next;
        }
        printf("\n");
    }
}

void list_empty(DLinkList L) {
    DNode *p;

    while (L->next != L) {
        p = L->next;
        L->next = p->next;
        free(p);
    }
    L->prior = L;
}

void list_destroy(DLinkList *L) {
    DNode *head = (*L)->next, *tmp;

    while (head != *L) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
    free(head);
    *L = NULL;
}
呦，又写BUG呢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言编程题之链表操作设计链表.zip
03-30
c语言 c语言编程题之链表操作设计链表
学生信息管理系统（链表&&C语言）
qq_59708493的博客
01-11 6046
学生信息管理系统总源码（可直接复制运行）
链表的创建与使用
m0_74214501的博客
01-15 2988
链表的基本介绍与使用
关于链表的建立与操作（c++实现）
weixin_74943550的博客
08-06 5059
因为线性表是静态线性的存储结构，所以为了方便动态地对数据进行处理，我们引入链表这一数据结构。因为链表是动态的存储结构，所以存储在其中的数据地址不一定是连续的。因此在创建链表时不仅需要保存数据本身，还需保存它的地址。所以我们就用一个结构体来存储链表的结点。其中每个结点都要包含两个领域，分别是数据域和指针域，用于存储数据和存储下一个结点的地址。int data;//这里的data可以是任意数据类型 struct node * link;} LNode;
数据结构-链式栈（C语言）
qq_59614938的博客
09-06 223
数据结构链式栈的代码实现
牛客在线编程之链表
young_man2的博客
09-27 712
牛客在线编程之链表
c语言编程题之链表操作回文链表.zip
03-30
c语言 c语言编程题之链表操作回文链表
c语言编程题之链表操作链表的中间节点.zip
最新发布
04-02
c语言 c语言编程题之链表操作链表的中间节点
c语言编程题之链表操作删除链表中的节点.zip
03-30
c语言 c语言编程题之链表操作删除链表中的节点
c语言链表编程实例
05-07
该文档综合了所有的链表程序，包括如何创建、删除、增加节点的具体实例，以文档代码的形式呈现了不一样的链表学习方法。
C语言——建立一个链表表示学生的信息（学号、姓名、分数）
10-12
1、输入学生信息，建立链表； 2、输出链表中全部学生信息； 3、根据姓名检索学生信息； 4、打印成绩不及格学生名单。
C语言单链表实现
01-16
c语言单链表的简单实现代码，有初学者的小伙伴可以参考一下。
数据结构-c语言代码实现-串基本操作（链式）
m0_65204379的博客
04-19 585
【代码】数据结构-c语言代码实现-串基本操作（链式）
c语言链式编程
qq_37813963的博客
07-12 306
一种c语言封装方法
链表（c语言实现）
热门推荐
zjq_love的博客
03-30 2万+
1.链表的分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： （1）单向或者双向 （2）带头或者不带头 （3）循环或者非循环 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。 2.无头单向非循环链表的实现 // ...
链表编程题
weixin_42788519的博客
11-17 755
数据结构、链表、王道
c语言链表编程作业,C语言基础教程之链表
weixin_36098237的博客
05-16 180
(一)什么是链表？链表是一种常见的基础数据结构，是一种线性表，是一种在物理存储单元上非连续非顺序的存储结构。链表有一系列节点构成，节点在运行时动态生成，每个节点包括数据域，数据域存储当前节点的信息，指针域存储下一个节点的手地址。(二)为什么要使用链表？顺序存储对空间的利用率不高；内存随着时间的增加会找不到大块的顺序空间；数组的大小只能是固定的，增加或删除都会移动大量数据；链式存储大小可以伸缩；链式...
编程基础 —— 链表
waywardG的博客
07-06 173
目录1 单链表的逻辑结构与存储结构2 单链表的定义3 插入元素4 删除元素5 创建单链表（1）尾插法（2）头插法6 双链表7 循环链表（1）循环单链表（2）循环双链表8 练习（1）移除链表元素（2）旋转链表 带头节点的单链表（写代码方便） 不带头节点的单链表（写代码麻烦） 3 插入元素 4 删除元素 5 创建单链表 （1）尾插法 （2）头插法 6 双链表 解决单链表无法逆向索引的问题 7 循环链表 （1）循环单链表 从一个结点出发可以找到其他任何结点
C语言之链表详解
Wang_XB_3434的博客
04-10 5765
链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个值和指向下一个节点的指针。链表的特点是可以动态添加和删除节点，而不需要预先知道数据的数量。与数组不同，链表中的节点不一定是连续的存储空间，因此可以有效地利用内存空间。int val;
链表C语言贪吃蛇作业
09-09
链表C语言贪吃蛇作业是一个适合C语言入门者学习和练习的项目。通过使用链表数据结构来...总之，链表C语言贪吃蛇作业是一个适合学习和练习链表和基本游戏逻辑的项目，通过实践可以提高编程能力和理解数据结构的运用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值