单链表操作全解析：代码实现与技巧

最新推荐文章于 2025-11-12 11:53:27 发布
原创 最新推荐文章于 2025-11-12 11:53:27 发布 · 561 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法

一.图示

头节点是一个节点，本质上是一个结构体变量，区分数据域和指针域

二.代码实现

头指针具有标识作用，所以常常会用头指针冠以链表的名字。所以你定义一个链表，那么链表的名字一般就是这个链表的头指针。

1.定义

在这里LNode *L和LinkList L 所生成的内容是一样的

LinkList 强调单链表，LNode*强调节点

 typedef struct LNode {
     int data;           //数据域，每一个节点存放一个数据元素
     struct LNode *next; //指针域，指针指向下一个节点
 }LNode,*LinkList;

2.增加新的结点

每一次增加新的节点时，我们都要检查新结点是否分配成功，防止内存不足造成没有分配节点

 LNode *p=(LNode *)malloc(sizeof(LNode));//增加一个新的节点，在内存中申请一个节点所需要的空间，并用指针p指向这个节点
 if(p==NULL) return false;

3.初始化定义带头节点的单链表

 bool InitList(LinkList& L) {
     L = (LNode*)malloc(sizeof(LNode));  //分配一个头节点
     if (L == NULL) return ;   //检查内存是否分配成功
     L->next = NULL;          //头节点的next指针指向NULL
     return true;

4.判断是否为空

 bool Empty(LinkList L) {
     return L->next == NULL;   //检查头结点的'next'指针是否为NULL，如果是，则链表为空
 }

5.求单链表的长度

 int Length(LinkList L) {
     LNode* p;
     p = L->next;
     int len = 0;           //用于计数有效节点的变量
     while (p != NULL) {
         len++;
         p=p->next;
     }
     return len;
 }

6.打印单链表

 void Print(LinkList L) {
     LNode* p;
     p = L->next;
     while (p != NULL) {
         cout << p->data << " ";
         p = p -> next;
     }
     cout << endl;
 }

7.尾插法(一开始没有数据，一直在里面输入元素，直到输入9999)

 bool ListPushBack(LinkList& L) {
     int x;
     L = (LNode*)malloc(sizeof(LNode));
     if (L == NULL) return false;
     L->next = NULL;
     LNode* s;        //临时节点，用于存储输入的元素
     LNode* r = L;    //尾节点指针，初始指向头指针
     cout << "请输入要在尾部插入的元素:(输入9999结束输入)" << endl;
     cin >> x;
     while (x != 9999) {    //输入9999表示结束
         s = (LNode*)malloc(sizeof(LNode));
         if (s == NULL) return false;
         s->data = x;
         r->next = s;    //尾节点的下一个指针指向新节点
         r = s;          //更新尾节点指针，使其指向新结点
         cin >> x;
     }
     r->next = NULL;  //尾节点的下一个指针指向NULL，表示链表结束
     return true;
 }

8.头插法(一开始没有数据，一直在里面输入元素，直到输入9999)

 bool ListPushFront(LinkList& L) {
     int x;   LNode* s;
     L = (LNode*)malloc(sizeof(LNode));
     if (L == NULL) return false;
     L->next = NULL;
     cout << "请输入要在头部插入的元素:(输入9999结束输入)" << endl;
     cin >> x;
     while (x != 9999) {
         s = (LNode*)malloc(sizeof(LNode));
         if (s == NULL)  return false;
         s->data = x;
         s->next = L->next;
         L->next = s;
         cin >> x;
     }
     return true;
 }

9.在指定p节点之后插入元素elem

 bool ListInsertNext(LNode* p, int elem) {
     if (p == NULL) return false;
     LNode* s = (LNode*)malloc(sizeof(LNode));
     if (s == NULL) return false;
     s->data = elem;
     s->next = p->next;
     p->next = s;
     return true;
 }

10.在指定p节点之前插入元素elem

 bool ListInsertPrior(LNode* p, int elem) {
     if (p == NULL) return false;
     LNode* s = (LNode*)malloc(sizeof(LNode));
     if (s == NULL) return false;
     s->data = elem;
     s->next = p->next;
     p->next = s;
     s->data = p->data; //相当于交换数据域
     p->data = elem;
     return true;
 }

11.查找指定位序i的值,返回节点

 LNode* GetElem(LinkList L, int i) {
     if (i < 1) return NULL;
     LNode* p;
     int j = 0;
     p = L;
     while (p != NULL && j < i) {
         p = p->next;
         j++;
     }
     return p;
 }

12.查找链表中是否有指定元素的值,如果没有，就返回NULL

 LNode* LocateElem(LinkList L, int elem) {
     LNode* p;
     p = L->next;
     while (p != NULL && p->data != elem) {
         p = p->next;
     }
     return p;
 }

13.按位序插入

在表L中第i个位置上插入指定元素elem

  • 找到第i-1个结点，将新结点插入其后

  • 这一段的代码顺序不能发生改变，必须先让s的下一个节点连接到p的下一个节点，然后让p的下一个节点指向s

     s->data = elem;
 s->next = p->next;
 p->next = s;  
 bool ListInsert(LinkList& L, int i, int elem) {
     LNode* p = GetElem(L, i - 1);
     if (p == NULL) return false;
     return ListInsertNext(p, elem);
 }

14.按位序删除

 bool ListDelete(LinkList& L, int i) {
     if (i < 1) return false;
     LNode* p = GetElem(L, i-1);
     if (p->next == NULL) return false;
     LNode* q = p->next;  //q指向待删除节点,p->next指向待删除节点的下一个节点
     p->next = q->next;
     free(q);
     return true;
 }

三.详细代码实现

#include<iostream>
using namespace std;
//定义一个带头链表
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode, * LinkList;
//初始化链表
bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));  //分配一个头节点
	if (L == NULL) return false;
	L->next = NULL;          //头节点的next指针指向NULL
	return true;
}
//判断链表是否为空
bool Empty(LinkList L) {
	return L->next == NULL;
}
//查找指定位序i的值,并返回节点
LNode* GetElem(LinkList L, int i) {
	if (i < 1) return NULL;
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
//在指定p节点之后插入元素elem
bool ListInsertNext(LNode* p, int elem) {
	if (p == NULL) return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;
	s->data = elem;
	s->next = p->next;
	p->next = s;
	return true;
}
//在p节点之前插入元素elem
bool ListInsertPrior(LNode* p, int elem) {
	if (p == NULL) return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;
	s->data = elem;
	s->next = p->next;
	p->next = s;
	s->data = p->data; //相当于交换数据域
	p->data = elem;
	return true;
}
//查找指定的值,如果没有，就返回NULL
LNode* LocateElem(LinkList L, int elem) {
	LNode* p;
	p = L->next;
	while (p != NULL && p->data != elem) {
		p = p->next;
	}
	return p;
}
//在第i个位置上插入元素e
bool ListInsert(LinkList& L, int i, int elem) {
	LNode* p = GetElem(L, i - 1);
	if (p == NULL) return false;
	return ListInsertNext(p, elem);
}
//删除第i个位置上的元素
bool ListDelete(LinkList& L, int i) {
	if (i < 1) return false;
	LNode* p = GetElem(L, i-1);
	if (p->next == NULL) return false;
	LNode* q = p->next;  //q指向待删除节点,p->next指向待删除节点的下一个节点
	p->next = q->next;
	free(q);
	return true;
}
//求单链表的长度
int Length(LinkList L) {
	LNode* p;
	p = L->next;
	int len = 0;
	while (p != NULL) {
		len++;
		p = p->next;
	}
	return len;
}
//尾插法(一开始没有数据，一直在里面输入元素，直到输入9999)
bool ListPushBack(LinkList& L) {
	int x;
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL) return false;
	L->next = NULL;
	LNode* s;        //临时节点，用于存储输入的元素
	LNode* r = L;    //尾节点指针，初始指向头指针
	cout << "请输入要在尾部插入的元素:(输入9999结束输入)" << endl;
	cin >> x;
	while (x != 9999) {    //输入9999表示结束
		s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL) return false;
		s->data = x;
		r->next = s;    //尾节点的下一个指针指向新节点
		r = s;          //更新尾节点指针，使其指向新结点
		cin >> x;
	}
	r->next = NULL;  //尾节点的下一个指针指向NULL，表示链表结束
	return true;
}
//头插法(一开始没有数据，一直在里面输入元素，直到输入9999)
bool LIstPushFront(LinkList& L) {
	int x; LNode* s;
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL) return false;
	L->next = NULL;
	cout << "请输入要在头部插入的元素:(输入9999结束输入)" << endl;
	cin >> x;
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL) return false;
		s->data = x;
		s->next = L->next;
		L->next = s;
		cin >> x;
	}
	return true;
}
//打印单链表
void Print(LinkList L) {
	LNode* p;
	p = L->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;

	}
	cout << endl;
}
int main() {
	LinkList L;
	return 0;
}

28、链表操作与优化：单链表与双链表的深入解析
tensorflowjs6的博客
06-30 61
本文深入解析了单链表和双链表的操作与优化技巧。内容涵盖单链表的扩展操作、双链表的基本结构、向双链表插入元素的详细实现、代码简化技巧以及双链表的其他操作如搜索和删除。此外，还对单链表与双链表的特性进行了对比总结，并提出了编程注意事项与技巧，帮助开发者更好地理解和应用链表结构。
单链表及代码实现
2501_90159374的博客
10-06 921
循环遍历链表：当p->next不为空时(存在可删除节点)，用tmp暂存p->next，更新p->next跳过待删除节点，用free(tmp)释放节点内存，同时table->count递减。定义遍历指针p（指向dummy），循环移动p，当p->next不为空且p->next->val!定义暂存指针tmp指向目标节点（p->next），更新p->next跳过目标节点（p->next = tmp->next）循环遍历链表：当p不为空时，打印p->val（节点数据）并加制表符分隔，再移动指针p。
单链表基本操作代码
urbeen的博客
07-12 2361
#include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; //头插法建立单链表 LinkList Link_HeadInsert(LinkList &L){ LNode *s; int x; L = (LinkList)malloc(size.
单链表的基本操作（完整代码）
热门推荐
weixin_44195690的博客
08-05 1万+
函数说明????： LinkList List_HeadInsert(LinkList& L)：用头插法建立单链表 LinkList List_TailInsert(LinkList& L)：用尾插法建立单链表 LNode * GetElem(LinkList L, int i):按照序号查找结点值 LNode * LocateElem(LinkList L,int i) ：按值查找表结点 bool InsetElem(LinkList& L, int i, int e) :插入
深入理解单链表：C语言实现与操作全解析
2501_90200491的博客
03-23 1257
/ 数据域// 指针域} SLTNode;核心说明data：存储整型数据（可自定义为其他类型）。next：指向下一个节点的指针，用于连接链表中的各个节点，形成链式结构。
数据结构与算法 - 单链表的核心操作：初始化、插入、删除的代码逻辑
千淘万漉虽辛苦，吹尽狂沙始到金
10-12 8687
数据结构与算法：单链表核心操作解析 本文深入剖析单链表的三大核心操作：初始化、插入和删除。主要内容包括： 单链表特性：由数据域和指针域组成，动态灵活但访问效率低于数组 初始化方法： 空链表初始化 数组构建的尾插法（高效O(n)）和头插法（逆序） 插入操作： 头部插入（O(1)） 尾部插入（遍历法O(n)） 中间插入（需定位前驱节点） 关键技巧： 使用哨兵节点简化逻辑 维护尾指针提高效率 详细图解和复杂度分析 对比分析： 单链表与数组的特性差异 不同插入方法的性能比较 本文通过清晰的代码示例和可视化图解，帮助
《单链表经典问题全解析：5 大核心题型（移除元素 / 反转 / 找中点 / 合并 / 回文判断）实现与详解》
2403_87212593的博客
09-03 641
本文摘要： 本文系统讲解了五种链表操作算法：1)移除指定元素节点，通过遍历筛选和尾指针优化；2)反转链表，使用三指针原地反转；3)快慢指针法查找中间节点；4)合并有序链表，采用虚拟头节点简化操作；5)判断回文结构，结合快慢指针、链表反转和双指针对比。每种算法均包含核心思路、代码结构解析、边界处理说明和完整实现，重点突出了指针操作技巧和空间复杂度优化（O(1)），适用于面试准备和算法学习。
单链表的基础实现与操作
weixin_31419153的博客
09-16 1199
本文还有配套的精品资源，点击获取 简介：单链表是数据结构的基础，尤其适用于存储动态数据集合。本文章通过C语言讲解了单链表的定义、节点结构、以及如何通过结构体和指针操作实现链表的基本操作，包括创建节点、插入节点、删除节点和遍历链表。文章提供了具体的代码示例，并强调了内存管理的重要性。此外，还提到了链表在实际应用中的扩展操作，如排序、查找和反转链表等，旨在帮助学习者通过实践进一...
手撕代码：单链表十大核心问题解析
2302_79963723的博客
05-07 779
本文梳理了10个经典单链表算法题，涵盖从基础操作到高阶技巧的完整知识链。在这里你可以学到：链表反转的迭代实现，快慢指针的巧妙应用（环检测、中间节点定位），链表合并与排序的高效策略，相交链表、环入口等问题的数学推导，深拷贝带随机指针链表的O(1)空间解法。现在，让我们一起揭开单链表算法的核心秘密！
单链表实现与应用：全面分析与C语言源码解析
C语言提供了操作单链表的低级接口，而实验报告则记录了实现和操作单链表的详细步骤和经验。 通过实践编写单链表的源码，学习者可以加深对数据结构的理解，并提升解决问题的能力。同时，源码中的注释应该详尽，有助...
单链表基础操作：反转与构建技巧
反转链表是常见的链表操作，例如Python代码中的`ReverseList`函数，通过创建新节点并将其链接到已反转的部分来实现。初始化两个指针，一个用于当前节点，一个用于前一个节点，然后逐步将节点插入到正确的位置，最后...
C++实现单链表：源代码解析与功能演示
- LinkList.h：此文件应为单链表实现的头文件，它可能声明了链表节点的数据结构以及所有与链表操作相关的函数原型，供LinkList.cpp文件中的源代码使用。 以上内容展现了单链表在C++中的实现细节以及与之相关的编程...
深入解析单链表操作：创建、插入、删除及遍历代码实现
循环链表的创建、插入和删除操作与单链表类似，但是在处理边界情况时，需要特别注意，确保不会产生无限循环。 通过上述代码和解释，可以看出单链表是一个高效的数据结构，在需要快速插入和删除的场景中非常有用。而...
零基础入门C语言之C语言实现数据结构之单链表经典算法
最新发布
su17643217590的博客
11-12 1175
本文介绍了6道经典单链表算法题目以及多种解决方法。
『 数据库 』MySQL索引深度解析：从数据结构到B+树的完整指南
小侯宝的博客
11-08 681
本文系统地阐述了MySQL索引的完整知识体系。首先从数据结构基础出发，通过顺序表与链表的对比分析，揭示了不同数据组织方式对操作效率的影响。进而深入硬件层面，解释了MySQL以16KB页为单位与磁盘交互的机制，以及局部性原理在数据库优化中的应用。 核心部分详细剖析了MySQL采用B+树作为索引结构的原因，对比了二叉树、哈希等其他数据结构的优劣，并阐述了B+树矮胖特性对减少磁盘IO次数的优势。文章区分了聚簇索引与非聚簇索引的本质差异，解释了回表查询的原理。通过实际示例展示了索引对查询性能的显著提升，同时...
零基础入门C语言之C语言实现数据结构之顺序表
su17643217590的博客
11-07 611
本文详细介绍了用C语言实现数据结构中的顺序表。顺序表本质是对数组的封装，分为静态和动态两种形式，其中动态顺序表通过内存分配更灵活。文章讲解了顺序表的初始化、销毁、增删查改等核心操作，包括尾插尾删、头插头删、指定位置插入删除等功能的实现。通过示例代码演示了动态扩容、元素查找等关键操作，并强调了数据结构在高效组织和管理数据方面的重要性。顺序表作为线性表的基础结构，为后续学习链表、栈等更复杂数据结构打下基础。
快速排序的常见构思
lsy1118的博客
11-09 574
快速排序三种常用划分区域的函数，1、直接取最左/右元素作为基准值；2、三元素取中法；3、快慢指针划分区域法
【数据结构】时间复杂度和空间复杂度
码银的博客
11-08 811
时间复杂度TnT(n)Tn描述算法执行时所有语句的总执行次数，本质是对计算工作量的量化。例如在Java中，这意味着我们需要关注循环、递归等操作随着问题规模nnn增长时的执行频率。核心是分析n→∞n→∞时的增长趋势（数量级），而非具体次数标准表示法为大O表示法TnOfnTnOfn))，其中fnf(n)fn映射基本运算与nnn的关系空间复杂度SnS(n)Sn表示算法运行时所需的辅助存储空间（不含输入数据本身）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值