数据结构之单链表（C语言代码及注释）

最新推荐文章于 2024-02-16 17:42:37 发布
最新推荐文章于 2024-02-16 17:42:37 发布
阅读量1.7k 收藏 21
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43965022/article/details/108642248
版权

一、单链表的特点

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

优点：元素的存储单元是任意的，可连续也可不连续；不需要限定长度。
缺点：其查找时间复杂度为O(n)；存放元素时需要另外开辟一个指针域的空间。

二、代码实现

头文件：SList.h

#ifndef SLIST_H_INCLUDED
#define SLIST_H_INCLUDED

#include <stdio.h>      //C语言标准库函数：用于输入和输出的函数、类型和宏。声明文件指针的FILE。常用的类型是size_t和fpos_t。
#include <malloc.h>     //是动态存储分配函数头文件,当对内存区进行操作时,调用相关函数。
#include <assert.h>     //assert函数像if判断语句中一样，然后如果该值为真则正常运行，否则报错，并调用abort(),产生异常中断，exit出来。

#define ElemType int    //定义数据元素类型为int
typedef struct Node     //定义节点
{
    ElemType data;      //数据类型
    struct Node *next;  //Node类型的next指针
}Node,*PNode;           //定义了结点的类型Node和指针类型PNode

typedef struct List     //定义出单链表的管理方式
{
    PNode first;    //指向头部
    PNode last;     //指向尾部
    size_t size;    //结点个数
}List;      //定义单链表的类型List

void InitList(List *list);                  //初始化链表
void push_back(List *list, ElemType x);     //声明尾插函数
void push_front(List *list, ElemType x);    //声明头插函数
void show_list(List *list);                 //声明显示函数
void pop_back(List *list);                  //声明尾删函数
void pop_front(List *list);                 //声明头删函数
void insert_val(List *list, ElemType x);    //声明按值插入函数
Node* find(List *list,ElemType key);        //声明查找函数（返回节点类型）
int length(List *list);                     //声明长度函数
void delete_val(List *list,ElemType key);   //声明按值删除函数
void sort(List *list);                      //声明排序函数
void reverse(List *list);                   //声明逆置函数
void clear(List *list);                     //声明清除函数
void destory(List *list);                   //声明摧毁函数

#endif // SLIST_H_INCLUDED

实现函数文件：

#include "SList.h"

void InitList(List *list)           //初始化函数的实现
{
    list->first = list->last = (Node*)malloc(sizeof(Node));  //申请了一个结点，将头和尾都指向该节点
    assert(list->first != NULL);    //检验结点是否申请成功
    list->first->next = NULL;       //这里必须要附为空，不然在头插时会乱码
    list->size = 0;                 //此时元素个数为0
}

void push_back(List *list, ElemType x)      //尾插函数的实现：从单链表的尾部插入数据
{
    Node *s = (Node *)malloc(sizeof(Node)); //申请一个新的结点，令s指向该结点
    assert(s != NULL);
    s->data = x;               //将要插入的值放人该结点的data中
    s->next = NULL;            //将它的next指针赋空（若不赋空，则是随机值，程序报错）

    list->last->next = s;
    list->last = s;            //将新结点链接进入list的尾部
    list->size++;              //元素个数加1
}

void push_front(List *list, ElemType x)      //头插函数的实现：从单链表的头结点的下一位开始插入节点
{
    Node *s = (Node *)malloc(sizeof(Node));
    assert(s!= NULL);
    s->data = x;
    s->next = NULL;               //添加新结点，并放入元素

    s->next = list->first->next;  //这里与尾插不同：在将新结点插入时，必须先让新结点的next指针先指向链表中
    list->first->next = s;        //再让头指针指向新结点
    list->size++;                 //元素个数加1
}

void show_list(List *list)        //显示链表函数的实现
{
    Node *p = list->first->next;  //创建一个Node类型的指针指向头结点
    while(p != NULL)              //由于尾结点为空,所以可以在遍历完链表后退出循环
    {
        printf("%d-->",p->data);
        p = p->next;
    }
    printf("Nul.\n");
}

void pop_back(List *list)      //尾删方法
{
    if(list->size == 0)        //如果链表长度为0，直接返回
    {
        return;
    }
    Node *p = list->first;
    while(p->next != list->last)   //去寻找尾结点的前驱结点
    {
        p=p->next;             //p最终指向尾结点的前驱结点
    }
    free(list->last);          //释放尾结点
    list->last = p;            //将尾指针指向p（原尾结点的前驱结点）
    list->last->next = NULL;
    list->size--;
}

void pop_front(List *list)     //头删方法的实现
{
    if(list->size == 0)        //如果链表长度为0，直接返回
    {
        return;
    }
    Node *p = list->first->next;
    list->first->next = p->next;    //头删比尾删简单，但应注意链表中仅有一个元素的情况
    free(p);
    if(list->size == 1)             //如果链表仅有一个元素，删除后，其尾首指针都应指向头结点
    {
        list->last = list->first;
    }
    list->size--;
}

void insert_val(List *list,ElemType x)     //按值插入函数的实现：前提是在链表有序的条件下按值插入
{
    Node *s = (Node *)malloc(sizeof(Node));        //创建一个新结点
    assert(s!= NULL);
    s->data = x;        //这里已经将要插入的值放入新结点中
    s->next = NULL;

    Node *p = list->first;
    while(p->next!=NULL && p->next->data<x)  //创建了新指针p去寻找s结点该插入的位置
    {
        p = p->next;
    }
    if(p->next == NULL)   //在尾部插入的情况
    {
        list->last = s;
    }
    s->next = p->next;
    p->next = s;
    list->size++;
}

Node* find(List *list,ElemType x)   //查询函数的实现：函数类型为指针类型，说明返回的是一个指针
{
    Node *p = list->first->next;
    while(p!=NULL && p->data!=x)    //遍历有没有等于x值的结点
    {
        p = p->next;
    }
    return p;
}

int length(List *list)    //链表长度函数的实现
{
    return list->size;
}

void delete_val(List *list,ElemType key)    //按值删除函数的实现
{
    if(list->size == 0)         //为空直接返回
    {
        return;
    }
    Node *p = find(list,key);   //查找该元素是否存在，存在则p指向该结点
    if(p == NULL)
    {
        printf("要删除的数据不存在。");
        return;
    }
    if(p == list->last)        //如果该值在链表尾部，则用尾删法
    {
        pop_back(list);
    }
    else                       //若在中间
    {
        Node *q = p->next;     //用q指向要删除结点的下一结点
        p->data = q->data;     //将下一结点的值赋给当前要删除结点的data
        p->next = q->next;     //将p所指的结点next跨过下一结点
        free(q);               //释放q结点
        list->size--;
    }
}

void sort(List *list)    //排序函数的实现：将链表从第一个结点后拆分成两个链表，再不断从后一链表中取值进来排序
{
    if(list->size==0 || list->size==1)
    {
        return;
    }
    Node *s = list->first->next;  //s指向第一个结点
    Node *q = s->next;            //q只想第二个结点

    list->last = s;
    list->last->next = NULL;  //从第一个结点后开始拆分（这里s指针就空出来了）

    while(q != NULL)
    {
        s = q;          //将s指针指向q所指链表的第一个结点
        q = q->next;    //q指向链表的下一元素

        Node *p = list->first;    //创建p指针去对新插入的结点排序
        while(p->next!=NULL && p->next->data<s->data)   //遍历链表寻找插入位置
        {
            p = p->next;
        }
        if(p->next == NULL)
        {
            list->last = s;
        }
        s->next = p->next;
        p->next = s;
    }
}

void reverse(List *list)   //逆置函数的实现：同理也是拆分成两个链表，不断进行头插达到逆置的效果
{
    if(list->size == 0 || list->size == 1)
    {
        return;
    }
    Node *p = list->first->next;
    Node *q = p->next;

    list->last = p;
    list->last->next = NULL;   //拆分成两个链表（排序函数相同）

    while(q != NULL)
    {
        p = q;          //p指向q的第一个结点
        q = p->next;    //q滑向下一结点

        p->next = list->first->next;
        list->first->next = p;     //头插结点（必须要让要插入的结点先链入表中）
    }
}

void clear(List *list)    //链表清除函数的实现
{
    if(list->size == 0)
    {
        return;
    }
    Node *p = list->first->next;  //p始终指向头结点的下一结点
    while(p != NULL)     //遍历元素，如果
    {
        list->first->next = p->next; //若到达最后一个元素，则其p->next为空则可退出循环
        free(p);         //释放p所指向的结点
        p = list->first->next;
    }
    list->last = list->first;
    list->size = 0;
}

void destory(List *list)  //摧毁链表函数的实现
{
    clear(list);          //先将链表清除
    free(list->first);    //再将头结点释放
    list->first = list->last = NULL;
    list->size = 0;
}

主函数：

#include "SList.h"

int main()
{
    List mylist;        //创建一个单链表
    InitList(&mylist);  //初始化单链表

    ElemType Item;      //定义一个int类型的数
    Node *p = NULL;     //定义一个Node类型的指针
    int select = 1;
    while(select)
    {
        printf("**********************************************\n");
        printf("*[1]  push_back             [2]  push_fornt  *\n");    //尾插   头插
        printf("*[3]  show_list             [4]  pop_back    *\n");    //显示   尾删
        printf("*[5]  pop_list              [6]  insert_val  *\n");    //头删   按值插入
        printf("*[7]  find                  [8]  length      *\n");    //查找   链长
        printf("*[9]  delete_val            [10] sort        *\n");    //按数值删   排序
        printf("*[11] resver                [12] clear       *\n");    //逆置   清除
        printf("*[13] destroy               [0] qiut_system  *\n");     //摧毁   退出
        printf("**********************************************\n");
        printf("请选择：>");
        scanf("%d",&select);
        if(select == 0)
        {
            break;
        }
        switch (select)   //根据select值选择不同功能
        {
        case 1: //尾插
            printf("请输入要插入的数据（-1结束）：>");
            while(scanf("%d",&Item),Item != -1)
            {
                push_back(&mylist,Item);
            }
            break;
        case 2: //头插
            printf("请输入要插入的数据（-1结束）：>");
            while(scanf("%d",&Item),Item != -1)
            {
                push_front(&mylist,Item);
            }
            break;
        case 3: //显示
            show_list(&mylist);
            break;
        case 4: //尾删
            pop_back(&mylist);
            break;
        case 5: //头删
            pop_front(&mylist);
            break;
        case 6: //按值插入
			printf("请输入要插入的数据:>");
			scanf("%d",&Item);
			insert_val(&mylist,Item);
			break;
        case 7: //查询
            printf("请输入要查找的数据:>");
			scanf("%d",&Item);
			p = find(&mylist,Item);
			if(p == NULL)
            {
                printf("要查找的数据不存在。\n");
            }
            else
            {
                printf("查找成功，数据存在。\n");
            }
            break;
        case 8: //链表长度
            Item = length(&mylist);
            printf("链表当前长度为：>%d\n",Item);
            break;
        case 9: //按值删除
            printf("请输入要删除的值：>");
            scanf("%d",&Item);
            delete_val(&mylist,Item);
            break;
        case 10: //排序
            sort(&mylist);
            break;
        case 11: //逆置
            reverse(&mylist);
            break;
        case 12: //清除
            clear(&mylist);
            printf("链表清除成功，请重新输入数据。\n");
            break;
        case 13: //摧毁
            destory(&mylist);
            printf("链表摧毁成功，已自动退出程序。\n");
            exit(0);
            break;
        case 0: //退出
            break;
        default:
            printf("输入命令错误，请重新输入。\n");
            break;
        }
    }
    destory(&mylist);
    return 0;
}

/**
* 本次编程所得：
* 1.要考虑边界条件和特殊情况（最容易出bug的地方）。
* 2.牵扯到链表的操作，很少直接对链表中的数据直接进行操作，而是对链表整体或结构进行操作。
*/

三、说明

编写代码的IDE是CodeBlock。
代码百度网盘链接：
链接：https://pan.baidu.com/s/1opVhpl5Bbh8GK-aJN-dqeQ
提取码：x0q9

树下涂鸦
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构各种程序源代码
06-13
String，队列，二叉树，赫夫曼数，链队列，十字链表， 顺序表，稀疏矩阵等程序源码。
数据结构源码笔记（C语言）：线性表的单链表示
半个冯博士
08-07 909
/* LinkList.c*/ /*线性表的单链表示：函数实现*/ #include <stdio.h> #include <stdlib.h> //#include "LinkList.h" /*LinkList.h*/ /* 线性表的单链表示：类型和界面定义*/ /* 定义顺序表的元素类型。应根据需要修改 */ typedef int DataType; struct Node; /* 单链表结点类型 */ typedef struct Node * PNo
c语言实现数据结构中的链表源代码
热门推荐
u014574317的博客
03-23 1万+
#include #include typedef struct LNode *List; struct LNode { int data; List next; }; struct LNode L; List InitList(List PtrL) { PtrL = (List) malloc(sizeof(L)); PtrL->next = NULL; return PtrL
C语言数据结构之循环链表的简单实例
12-26
C语言数据结构之循环链表的简单实例 实例代码： # include # include typedef struct node //定义链表中结点的结构 { int code; struct node *next; }NODE,*LinkList; /*错误信息输出函数*/ void Error(char *message) { fprintf(stderr,"Error:%s/n",message); exit(1); } //创建循环链表 LinkList createList(int n) { LinkList head; //头结
C语言链表代码，注释详细
cooping
11-09 2614
C语言链表代码，注释详细，配套视频讲解如下 看动画学编程 | C语言链表概念详解 /* * C语言版本C99，如果编译器版本过低会无法编译 * 在CodeBlocks和VS2019上测试过 * 看代码遇到问题可以+Q: 1497161158 */ #include <stdio.h> #include <stdlib.h> // 导入库用于调用malloc函数动态分配内存 // 定义链表节点 typedef struct Node { int value; .
数据结构C语言代码示例，有详细注释
02-16
数据结构C语言 单链表 0_SingleLinkList.c 双链表 1_DualLinkList.c 递归 2_Recursion.c 栈 3_Stack.c 汉诺塔 4_Hanoi.c 二叉树 5_BinaryTree.c 最小堆 6_MinHeap.c 哈夫曼树 7_HuffmanTree.c 邻接...
数据结构与算法全集（C源代码+详细注释）
11-27
全集内容结构如下： ├─图 │ ├─关键路径（有向无环图及其应用2） │ │ 1.txt │ │ ALGraph.cpp │ │ ALGraph.h │ │ CriticalPath.cpp │ │ CriticalPath.h │ │ InfoType.cpp │ │ InfoType.h │ │ ...
C语言版数据结构，用单链表实现稀疏多项式的加法运算。
04-26
最近在学数据结构，讲完单链表后老师就布置了一个这样的答辩作业。代码附上啦，大多地方都添加了注释，要交作业的同学可以看一看。 实现要求： 1）两个一元稀疏多项式进行存储，并实现加法运算。 2）使用单链表的...
C语言版本 单链表实现，亲测可用
04-25
单链表操作较全面，代码风格良好，注释清晰
李春葆数据结构书上各算法实现
01-16
李春葆《数据结构》第四版。我把各种书上的算法按章节放在各自对应的一个头文件中，注释比较详细，可以按需查看。
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2373
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //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 {
C语言实现链表(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-14 1716
#include "stdio.h" #include "stdlib.h" #include "malloc.h" //5 个常量定义 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -1 //类型定义 typedef int Status; typedef int ElemType; //测试程序长度定义 #define LONGTH 5 //链表的类型 typedef struct LNode {
数据结构——链表 原理及C语言代码实现（可直接运行版）
m0_63596031的博客
02-16 455
存储都在数据段上，而在函数内部临时开辟的则存储在栈区（记忆技巧：栈区后来先出，生命周期短，适合存储临时使用的变量，在函数执行结束时会自动被释放），堆区存放的则是在函数运行过程中开辟出来的空间，需要程序员进行手动分区以及释放，也可能程序结束时由OS回收，所以也可能会发生内存泄漏问题。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
C语言实现数据结构——链队列
qq_52491380的博客
05-22 261
源码 /** * 创建时间 : 2022/5/21 20:16 * 作 者 : Marson * 内 容 : 队列的链式存储结构(带头结点) */ #include <stdlib.h> #include <stdio.h> #include <stdbool.h> typedef int ElemType; //队列结点 typedef struct QNode { ElemType data; struct QNode
c语言数据结构---链表
邓富民的博客
12-08 922
1.对链表的理解2.链表每个节点的创建3.输出链表链表的基本结构 首先，一条铁链，有多个节点，每两个节点之间会连接起来。 那么这些节点是如何创建的呢？ —结构体— 创建一个结构体类型，该结构体有两个成员，一个是数据data，一个是结构体指针。 为什么要这样创建呢？ 一条铁链，要有第一个节，第二个节，第三个节… 第一个节和第二个节之间，是不是互相扣在一起呢？下面： 结构体成员设置完后
C语言 数据结构 单链表的操作代码
haungxinhui的博客
01-16 370
/假设没有重复的该数据。
数据结构（C语言）--链表
研究生在读，记录学习历程
12-30 589
线性表的链式实现
数据结构——C语言实现 顺序表和链表代码
ZhangJiawen的博客
10-25 2718
今天敲了一下数据结构中顺序表的代码，发现C语言好久不用真的忘得差不多了。代码都是可以直接运行的（我的运行环境是Dev）。如果有写错的地方，欢迎大家留言一起讨论。 对这一部分概念的介绍可以参考这篇博客：数据结构中的顺序表 下来就直接看代码吧 #include<stdio.h> #define MAXSIZE 100 typedef struct{ int elem[MAXSIZE]; int length; }SeqList; //初始化 void Init_SeqList(SeqLis
数据结构--单向链表（C&&python）(不含虚拟头结点）
Yair_的博客
02-04 220
该函数修改了结构体，传递一个指针的地址，用一个二级指针接收。如果是一个一级指针接收一个一级指针，这只是临时拷贝。对该指针修改并不会修改链表。重命名一下，后面定义变量和整体的修改更方便。
数据结构循环单链表C语言完整代码（尾插法）
最新发布
06-13
数据结构中的循环单链表是一种特殊的链表，其中头节点的next指针指向尾节点，而尾节点的next指针又指向头节点，形成了一个环形结构。尾插法（pushing at the end）是向循环链表中添加新节点的一种常见方法，通常在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值