数据结构（c语言）笔记---单链表

已于 2023-07-21 19:17:37 修改
阅读量214 收藏
点赞数
文章标签： 数据结构 c语言 笔记
于 2023-07-21 19:14:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_65361882/article/details/131785409
版权
文章详细介绍了单链表的概念，包括如何用C语言定义单链表的数据结构，以及实现头插法、尾插法、初始化、判断空链表、后插入、前插入、按位序插入、按位序删除、删除结点、按位查找、按值查找、求链表长度和输出链表等操作。此外，强调了带头结点和不带头结点的区别，并提供了相应的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一，单链表的定义

单链表：线性表的链式存储，它是通过一组任意的存储单元来存储线性表中的数据元素。

单链表使用结点来存放数据元素和指向下一个结点的指针 ，结点用结构体来表示。                                                                                  

其中data为数据域，存放数据元素；next为指针域，存放其后继节点的地址。

代码如下：

#define ElemType int


typedef struct LNode{
    
    ElemType data;     //数据域
    struct LNode *next;//指针域
    
}LNode,*LinkList;

此处的 LNode  和  LinkList  是有各自作用的，  在下面的代码中会看到LNode *  和  LinkList两种形式，基础好的会发现两者都一样，没错，类型确实一样，但含义不同，LinkList强调这是一个单链表，LNode * 强调这是一个结点。 

还有一点，我提前说明，其实学完后可以通俗上理解，带头结点的有数据的单链表L中，L在代码中，其实就代表头结点的地址；不带头结点的有数据的单链表L中，L在代码中，其实就代表首结点的地址。当然考试中一定要具体题目 具体分析。

二，单链表的代码定义（以下均为c语言的实现）

一，头插法（带头结点和不带头结点）

//带头结点
LinkList List_HeadInsert(LinkList *L){    
    //先初始化链表
    (*L)=(LNode*)malloc(sizeof(LNode));
    (*L)->next=NULL;
    //声明需要的相关变量
    ElemType x;
    LNode *s;
    scanf("%d",&x);

    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=(*L)->next;
        (*L)->next=s;
        scanf("%d",&x);
    }

    return *L
}



//不带头结点
LinkList List_HeadInsert(LinkList *L){    
    //先初始化链表
    (*L)=NULL;
    //声明需要的相关变量
    ElemType x;
    LNode *s;
    scanf("%d",&x);

    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;  
        s->next=NULL;   
        if(NULL==(*L)){
            (*L)=s;
        }else{
            s->next=(*L);
            (*L)=s;
        }

        scanf("%d",&x);
    }

    return *L
}

二，尾插法（带头结点和不带头结点）

//带头结点

LinkList List_TailInsert(LinkList *L){
    
    //初始化单链表
    (*L)=(LNode*)malloc(sizeof(LNode));
    
    LNode *p=(*L);        //声明始终需要指向尾结点的结点
    LNode *s;        //声明插入的结点
    Ex;          //插入的元素值
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        p->next=s;    //将s插到p后面
        p=s;        //p始终指向当前最后一个结点
        
        scanf("%d",&x);
    }
    p->next=NULL; //声明最后一个结点后为NULL
    return *L;
}



//不带头结点

LinkList List_TailInsert(LinkList *L){
    
    //初始化单链表
    (*L)=NULL;
    
    LNode *p;        //声明始终需要指向尾结点的结点
    LNode *s;        //声明插入的结点
    ElemType x;          //插入的元素值

    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=NULL;
        if(NULL==(*L)){
            (*L)=s;
            p=*L;
        }else{
            p->next=s;    //将s插到p后面
            p=s;        //p始终指向当前最后一个结点
        }


        
        scanf("%d",&x);
    }
    p->next=NULL; //声明最后一个结点后为NULL
    return *L;
}

三，初始化单链表

初始化不带头结点的单链表
bool InitList(LinkList *L){
	*L = NULL;
	return true;
}


//初始化带头结点的单链表
bool InitList(LinkList* L) {    //c语言语法中，这里是一个双指针，，在下面内存分配中，需要先解引用(*L)

	(*L) = (LNode*)malloc(sizeof(LNode));   
	if (*L == NULL) {
		return false;
	}
	(*L)->next = NULL;
	return true;
}

四，判断单链表是否为空

判断不带头结点的单链表是否为空
bool Empty(LinkList *L) {
	return (L == NULL);
}


//判断带头结点的单链表是否为空
bool Empty(LinkList *L) {
	return ((*L)->next == NULL);
}

五，后插入结点

//在一个结点后插入一个新结点
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL) {
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) {
		return false;
	}
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

六，前插入结点

//在一个结点前插入一个新结点
//常规操作是先扫描全表，找到结点的前驱结点，然后在插入，此方法时间复杂度为O(n);
//而下面的方法，为：偷天换日，交换结点之间的值（data），此方法时间复杂度为O(1);
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL) {
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) {
		return false;
	}
	s->next = p->next;    //先将s结点插到p结点后面
	p->next = s;

	s->data = p->data;    //交换s和p结点的值
	p->data = e;

	return true;
}

七，按位序插入

//按位序插入（不带头结点） 
//在第i个位置上插入e
//平均时间复杂度为O（n）
bool ListNoHeadInsert(LinkList* L, int i, ElemType e) {
	if (i < 1) {
		return false;
	}
	if (i == 1) {  //头结点需要特别插入
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = *L;
		*L = s;
		return true;
	}
	LNode* p;  //指针p表示当前扫描到的那个结点
	int j = 1;//表示当前指向第几个结点
	p = (*L);   //p指向第一个结点（不是头结点）
	while (p != NULL && j < i - 1)//p->next != NULL  不能只使用这个，否则i合不合法就不能知道了
	{
		p = p->next;
		j++;
	}
	if (p == NULL) {
		printf("i不合法\n");
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));  //创建一个结点
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//按位序插入（带头结点） 
//在第i个位置上插入e
//平均时间复杂度为O（n）
bool ListInsert(LinkList* L,int i,ElemType e) {
	if (i < 1) {
		return false;
	}
	LNode* p;  //指针p表示当前扫描到的那个结点
	int j = 0;//表示当前指向第几个结点
	p = (*L);   //指向头结点 ，头结点是第0个结点（不存储数据）
	while (p != NULL && j < i - 1)//p->next != NULL  不能只使用这个，否则i合不合法就不能知道了
	{
		p = p->next;
		j++;
	}
	//if (p == NULL) {
	//	printf("i不合法\n");
	//	return false;
	//}
	//LNode* s = (LNode*)malloc(sizeof(LNode));  //创建一个结点
	//if (s == NULL) {
	//	return false;//防止内存分配失败
	//}
	//s->data = e;
	//s->next = p->next;
	//p->next = s;
	//return true;
	bool m = InsertNextNode(p, e);
	return m;  //调用另一个函数 （封装）
}

八，按位序删除一个结点

//按位序删除一个结点（带头结点）
bool ListDelete(LinkList* L, int i, ElemType *e) {
	if (i < 1) {
		return false;
	}
	LNode* p;
	int j = 0;
	p = *L;

	while (p!=NULL && j<i-1) {  //要删除第i个结点，就要找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL) {
		return false;
	}
	if (p->next == NULL) {  //确认p后面有结点删
		return false;
	}
	LNode* q = p->next; //q指向要删除的结点
	*e = q->data;  //返回q的data
	p->next = q->next;
	free(q);
	return true;
}

九，删除一个结点

//直接删除一个结点
//交换数据，时间复杂度为 O（1）
bool DeleteNode(LNode *p) {

	if (p == NULL) {
		return false;
	}
	LNode* q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	return true;
}

十，按位查找按值查找

//按位查找，返回第i个结点 （带头结点）
LNode* GetElem(LinkList *L,int i) {
	if (i < 0) {
		return NULL;
	}
	int j = 0;
	LNode* p;
	p = *L;
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}


//按值查找
LNode* LocateElem(LinkList *L,ElemType e) {
	LNode* p = *L;
	while (p!=NULL && p->data!=e) {  //此处ElemType是int类型，如果此处是结构体的话，需要写一个函数进行比较
		p = p->next;
	}
	return p;  //找到后返回结点的指针，否则返回NULL

}

十一，求长度

//求单链表的长度(带头结点)
int Length(LinkList* L) {
	int len = 0;
	LNode* p = *L;
	while (p->next!=NULL) {
		p = p->next;
		len++;
	}
	return len;

}

十二，输出单链表

//输出单链表(带头结点)
void PrintList(LinkList* L) {

	LNode* p = (*L);

	while (p->next != NULL) {
		p = p->next;
		printf("%d ",p->data);
	}
	printf("\n");
}


//输出单链表(不带头结点)
void PrintListNoHead(LinkList* L) {

	LNode* p = (*L);

	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

三，单链表对于整个链表来说是基础非常重要

C语言后记-29 嵌入式软件数据结构的特点
CodeAllen嵌入式
08-22 3万+
嵌入式系统的定义是：以应用为中心，以计算机技术为基础，软件硬件可以裁剪，适应应用系统对功能、可靠性、成本、体积、功耗严格要求的专用计算机系统。通俗来说，除了通用计算机，比如笔记本电脑和台式机电脑之外的所有包含CPU的系统都是嵌入式系统。嵌入式操作系统因为近年来的发展，其种类和功能已经多种多样，如果从性能上分的话，主要有高级嵌入式系统和中低档嵌入式系统。高级嵌入式主要是给类似于收集，数码相机之类的多媒体设备使用。这类设备对硬件的要求很高，RAM比较大，CPU的速度也比较快。
数据结构查找题目及代码
12-20
实验题目包括1.实现并运行顺序查找。2.实现并运行二分查找。3.根据输入的数字，构造一棵二叉判定树。
【数据结构】【C语言】 链表知识点+笔记
Mr_VK的博客
08-22 199
1. 内存4区 代码区：函数代码，存放在代码区，函数名就是这个函数的地址 全局区：全局的变量，字符串常量 栈区：系统开辟和释放 堆区：用户决定要开辟多大内存？装什么数据？使用完后还要不要继续使用？ 用户自己需要决定开辟和释放 内存示意图： #include<stdlib.h> Int *p; P=(int *)molloc(size); //在堆区开辟size个字节的内存 //指针p指向这段内存 //用molloc去开辟的内存不会自动释放，需要手动释放 Free(p)
C语言数据结构——链表
wxk2227814847的博客
01-28 2445
在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。
数据结构-按位置查找函数
欢迎来到斛XX的博客
07-19 401
C语言数据结构-按位置查找
数据结构--单链表的按值、位查找
si001012的博客
08-04 1071
数据结构的基础单链表的按位、值进行查找
算法数据结构学习笔记-C语言.zip
01-01
本学习笔记将深入探讨数据结构的基础知识，以及如何在C语言中实现这些结构。 1. **数组**：数组是最基本的数据结构，它是由相同类型元素的集合组成，通过索引进行访问。在C语言中，数组可以是一维、二维或多维的，...
C语言数据结构-链表
2302_81072215的博客
11-26 1771
图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。
数据结构学习笔记--带头结点的单链表的多种初始化及销毁方法（c/c++实现）
weixin_58526281的博客
08-08 3866
本知识点主要需要注意的是函数所传入参数的指针取值与取地址的区别，加深对c语言中指针的理解。
c++数据结构 静态分配 顺序表 按位查找
qq_45604718的博客
08-03 164
c++学习
单链表的定义以及使用
aome1470的博客
03-21 145
链表是一种有序的列表，它的内容通常存储与内容分散的位置上。 一般链表的串联方式有两种： 一种是通过数组有序串联链表的列表元素，通常用到两个数组，一个数组存放数据，一个数组存放链接的关系。这种链表的缺点在于，在插于或者删除元素的时候，要频繁的搬动元素，而且数组的大小是固定的，使用缺乏弹性。 另一种则是动态内存配置的链表，它由许多的结点（Node）链接而成，每一个结点包含数据部分以及指...
单链表的定义初始化、CRUD （超详细、完整代码）
m0_60284144的博客
04-15 3147
int data;
[数据结构]代码：单链表的定义和基本操作
hula_hula_的博客
01-27 619
简单写了一些基本操作，希望大佬们能指正。 #include <iostream> using namespace std; template <class T> struct ListNode { T data; ListNode<T>* next; ListNode() : data(0), next(nullptr) {} ListNode(T val) : data(val), next(nullptr) {} ListNode(T val, Li
单链表的定义及其代码实现
qq_45965736的博客
09-09 1155
对不带头结点与带头结点的链表的比较
单链表详解（代码逐条详解）
最新发布
Xian_haichi的博客
12-27 959
近7000字的详解，深度刨析每行代码
单链表概念及代码
KMP查找法
02-03 372
一、概念 单链表是一种链式存储的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 二、代码 1、头文件 #include<stdio.h> #include<assert.h> #include<s...
单链表定义
weixin_50311592的博客
04-21 2362
单链表 定义 特点：每个结点除了存放数据元素外，还要存储指向下一个节点的指针 优点：不要求大片连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针 用代码定义一个单链表 struct LNode{//定义单链表结点类型 ElemType data;//每个节点存放一个数据元素，data数据域 struct LNode *next;//指针指向下一个节点，next指针域 }; struct LNode *p=(struct LNode *)malloc(sizeof(struc
【数据结构】【线性表】单链表1—概念即创建(附C语言源码)
weixin_58498967的博客
11-09 764
由于有头结点的单链表具有天然的代码优势，因此在后续的内容中，如没有特殊说明，则代表该单链表为有头结点的单链表。两种，就链表定义而言，不需要头结点也是一个完整的链表，但在实际的运用中发现，没有头结点的单链表在继续数据运算时代码相对复杂(在链表的插入删除中可以体现，后文会讲），因此我们可以采用有头结点的单链表，使得代码简便的同时更加统一。由于单链表的物理存储结构是链式的，而不是顺序表的连续空间，因此在表示链表时，只说明头指针，指向链表的第一个结点，结点元素的next指针指向下一个结点构成链表。
单链表的定义
m0_64055811的博客
03-28 507
typedef 关键字 --数据类型重命名。typedef
C语言实现单链表数据结构详解
"这篇学习笔记主要介绍了如何在C语言中封装单链表...这篇学习笔记提供了关于C语言封装单链表对象的深入理解和实践指导，涵盖了单链表的基本操作和时间复杂度分析，对于理解和应用单链表数据结构具有重要的参考价值。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的玩家

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值