带头结点的单链表的操作实现（C语言）

最新推荐文章于 2024-04-27 11:18:51 发布
最新推荐文章于 2024-04-27 11:18:51 发布
阅读量2.3k 收藏 28
点赞数 5
分类专栏： 数据结构与算法 C语言 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51004248/article/details/120103190
版权

补充知识

链式存储结构存储线性表：把存储有数据元素的结点用指针域构造成链。

指针：指向物理存储单元地址的变量。

结点：一个由数据元素域及一个或若干个指针域组成的结构体。

单链表的定义

        链式存储结构的线性表称为链表。根据指针域的不同和结点构造链的方法不同，链表主要有单链表、单循环链表和双循环链表三种。其中，单链表——构造链表的结点只有一个指向直接后继结点的指针域。

单链表的表示

单链表中每个结点的结构

单链表分为带头结点结构和不带头结点结构两种。

我们把指向单链表的指针称作头指针。头指针所指的不存放数据元素的第一个结点称作头结点。

带头结点的单链表

 

不带头结点的单链表

 符号“^"表示空指针。空指针是一个特殊标记，用来表示链表的结束。

虽然看起来时连续的，但是链表的各个结点不一定是连续存储。（各个结点的地址不一定连续）

 带头结点的单链表和不带头结点的单链表的使用根据实际需求来确定。

带头结点的单链表的操作实现

  • 直接插入结点
//直接插入链表尾部
void AddList(SLNode *head, SLNode *node){
	SLNode *temp = head;  //头结点不能动，所以需要辅助遍历指针temp 
	
	while(temp->next != NULL)  //遍历找到temp最后一个结点位置 
		temp = temp->next;  //没有到最后就指向下一个结点位置
		
	//当推出while循环时，temp指向了最后一个结点
	//让temp的next指向待插入的结点
	temp->next = node; 
}
  • 按照结点编号插入

 

带头结点的单链表添加结点示意图

//按照编号顺序插入链表
int AddByOrder(SLNode *head, SLNode *node){
	SLNode *temp = head;  //头结点不能动，所以需要辅助遍历指针temp 
	
	//temp->next == NULL时，直接插入最后即可。
	//temp->next->no > node->no时，说明已经找到。
	//这里要特别注意是 temp->next->no，而不是temp->no，因为 temp->no是头结点的，而头结点没有信息 
	while(temp->next != NULL && temp->next->no < node->no) {
		temp = temp->next;
	}

	//判断temp->no是否等于node->no ,如果等于，则说明该编号结点已存在，不能插入
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(temp->next != NULL && temp->next->no == node->no){
		printf("编号为 %d 的结点已存在，不能插入\n", node->no);
		return 0;
	}
	
	//否则，则可以插入链表
	node->next = temp->next;  //新的结点->next = temp->next 
	temp->next = node;  //temp->next = 新的结点 
	
	return 1;
}
  • 修改结点信息
//修改结点信息
int UpdateNode(SLNode *head, SLNode *newnode){
	//根据结点 no 编号来修改，所以 no 编号不能动 
	SLNode *temp = head;  //头结点不能动，所以需要辅助遍历指针temp 
	
	//查找待修改结点的前一个结点
	//temp->next == NULL时，没有找到该节点 
	//这里要特别注意是 temp->next->no，而不是temp->no，因为 temp->no是头结点的，而头结点没有信息  
	while(temp->next != NULL && temp->next->no != newnode->no){
		temp = temp->next;
	} 
	
	//判断temp->no是否等于newnode->no ,如果等于，则说明该编号结点已找到
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(temp->next != NULL && temp->next->no == newnode->no){
		strcpy(temp->next->name, newnode->name);
		return 1;
	}else{
		printf("没有找到编号为 %d 的结点\n", newnode->no);
		return 0;
	}
}
  • 删除结点

 带头结点的单链表删除结点示意图

//删除编号为 no 的结点
int DelNode(SLNode *head, int no){
/*方法一： */
	//定义辅助指针 ,head暂时不能没有，故temp1指向head，temp2配合释放掉 
	SLNode *temp1 = head, *temp2 = NULL;
	
	//查找待修改结点的前一个结点
	//temp->next == NULL时，没有找到该节点 
	//这里要特别注意是 temp->next->no，而不是temp->no，因为 temp->no是头结点的，而头结点没有信息  
	while(temp1->next != NULL && temp1->next->no != no){
		temp1 = temp1->next;
	}
	
	//判断temp->no是否等于no ,如果等于，则说明该编号结点已找到
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(temp1->next != NULL && temp1->next->no == no){
		temp2 = temp1->next;  //temp2指向要删除的结点 
		temp1->next = temp1->next->next;  //删除
		free(temp2);
		temp2->next = NULL; 
		return 1;
	}else{
		printf("没有找到编号为 %d 的结点\n", no);
		return 0;
	}

/*方法二： 
	SLNode *temp1 = head, *temp2 = NULL;
	int j = 0; 

	while(temp1->next != NULL && temp1->next->next != NULL && j < no - 1){
		temp1 = temp1->next;
		j++;
	}
	
	//判断temp->no是否等于no ,如果等于，则说明该编号结点已找到
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(j != no - 1){
		printf("没有找到编号为 %d 的结点\n", no);
		return 0;
	}else{
		temp2 = temp1->next;  //temp2指向要删除的结点 
		temp1->next = temp1->next->next;  //删除
		free(temp2);
		temp2->next = NULL; 
		return 1;
	}
*/
}
  • 显示单链表
//显示链表【遍历】
int ShowList(SLNode *head){
	//定义temp辅助遍历 
	SLNode *temp = head->next;
	
	//判断链表是否为空 
	if(head->next == NULL){
		printf("链表为空\n");
		return 0;
	}
	
	//遍历单链表 
	while(temp != NULL){
		printf("[%d,%s]\n",temp->no,temp->name);  //打印链表结点 
		temp = temp->next;  //指向下一个结点 
	}
	
	return 1;
}
  • 撤销单链表
//撤销单链表
void Destroy(SLNode **head){
	//定义辅助指针 ,head暂时不能没有，故temp1指向head，temp2配合释放掉 
	SLNode *temp1 = NULL, *temp2 = NULL;
	
	//定义temp1辅助遍历 
	temp1 = *head;
	while(temp1 != NULL){  //最终：temp1 = NULL，temp2被释放 
		temp2 = temp1;   //temp2指向temp1，便于释放 
		temp1 = temp1->next;  //temp1指向下一个，避免链表丢失 
		free(temp2);  //释放temp2 
		temp2 = NULL;  //避免free都成为“野指针” 
	}
	*head = NULL;  //最后让head = NULL 
}

完整代码展示

#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
#include <malloc.h>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

//单链表的结点定义 
typedef struct Node{
	int no;   //编号 
	char name[10];  //姓名
	struct Node *next;  //Node类型的next指针 
}SLNode;

//单链表结点的初始化
void ListInitiate(SLNode **head){
	*head = (SLNode *)malloc(sizeof(SLNode));  //申请头节点，由head指示其地址
	(*head)->next = NULL;  //置结束标记NULL 
} 

//求当前数据元素个数
int ListLength(SLNode *head){
	SLNode *temp = head;  //头结点不能动，temp指向head
	int count = 0;   //count初始化为0 
	
	while(temp->next != NULL){  //循环计数，temp->next == NULL时，指向单链表的最后一个元素 
		temp = temp->next;  //指向下一个结点 
		count++;  //计数器加1 
	}
	return count;
} 

//直接插入链表尾部
void AddList(SLNode *head, SLNode *node){
	SLNode *temp = head;  //头结点不能动，所以需要辅助遍历指针temp 
	
	while(temp->next != NULL)  //遍历找到temp最后一个结点位置 
		temp = temp->next;  //没有到最后就指向下一个结点位置
		
	//当推出while循环时，temp指向了最后一个结点
	//让temp的next指向待插入的结点
	temp->next = node; 
} 

//按照编号顺序插入链表
int AddByOrder(SLNode *head, SLNode *node){
	SLNode *temp = head;  //头结点不能动，所以需要辅助遍历指针temp 
	
	//temp->next == NULL时，直接插入最后即可。
	//temp->next->no > node->no时，说明已经找到。
	//这里要特别注意是 temp->next->no，而不是temp->no，因为 temp->no是头结点的，而头结点没有信息 
	while(temp->next != NULL && temp->next->no < node->no) {
		temp = temp->next;
	}

	//判断temp->no是否等于node->no ,如果等于，则说明该编号结点已存在，不能插入
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(temp->next != NULL && temp->next->no == node->no){
		printf("编号为 %d 的结点已存在，不能插入\n", node->no);
		return 0;
	}
	
	//否则，则可以插入链表
	node->next = temp->next;  //新的结点->next = temp->next 
	temp->next = node;  //temp->next = 新的结点 
	
	return 1;
} 

//修改结点信息
int UpdateNode(SLNode *head, SLNode *newnode){
	//根据结点 no 编号来修改，所以 no 编号不能动 
	SLNode *temp = head;  //头结点不能动，所以需要辅助遍历指针temp 
	
	//查找待修改结点的前一个结点
	//temp->next == NULL时，没有找到该节点 
	//这里要特别注意是 temp->next->no，而不是temp->no，因为 temp->no是头结点的，而头结点没有信息  
	while(temp->next != NULL && temp->next->no != newnode->no){
		temp = temp->next;
	} 
	
	//判断temp->no是否等于newnode->no ,如果等于，则说明该编号结点已找到
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(temp->next != NULL && temp->next->no == newnode->no){
		strcpy(temp->next->name, newnode->name);
		return 1;
	}else{
		printf("没有找到编号为 %d 的结点\n", newnode->no);
		return 0;
	}
} 

//删除编号为 no 的结点
int DelNode(SLNode *head, int no){
/*方法一： */
	//定义辅助指针 ,head暂时不能没有，故temp1指向head，temp2配合释放掉 
	SLNode *temp1 = head, *temp2 = NULL;
	
	//查找待修改结点的前一个结点
	//temp->next == NULL时，没有找到该节点 
	//这里要特别注意是 temp->next->no，而不是temp->no，因为 temp->no是头结点的，而头结点没有信息  
	while(temp1->next != NULL && temp1->next->no != no){
		temp1 = temp1->next;
	}
	
	//判断temp->no是否等于no ,如果等于，则说明该编号结点已找到
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(temp1->next != NULL && temp1->next->no == no){
		temp2 = temp1->next;  //temp2指向要删除的结点 
		temp1->next = temp1->next->next;  //删除
		free(temp2);
		temp2->next = NULL; 
		return 1;
	}else{
		printf("没有找到编号为 %d 的结点\n", no);
		return 0;
	}

/*方法二： 
	SLNode *temp1 = head, *temp2 = NULL;
	int j = 0; 

	while(temp1->next != NULL && temp1->next->next != NULL && j < no - 1){
		temp1 = temp1->next;
		j++;
	}
	
	//判断temp->no是否等于no ,如果等于，则说明该编号结点已找到
	//要加上 temp->next != NULL 这个判断条件，否则，在链表为空时，temp->next->no会出现错误 
	if(j != no - 1){
		printf("没有找到编号为 %d 的结点\n", no);
		return 0;
	}else{
		temp2 = temp1->next;  //temp2指向要删除的结点 
		temp1->next = temp1->next->next;  //删除
		free(temp2);
		temp2->next = NULL; 
		return 1;
	}
*/
} 

//显示链表【遍历】
int ShowList(SLNode *head){
	//定义temp辅助遍历 
	SLNode *temp = head->next;
	
	//判断链表是否为空 
	if(head->next == NULL){
		printf("链表为空\n");
		return 0;
	}
	
	//遍历单链表 
	while(temp != NULL){
		printf("[%d,%s]\n",temp->no,temp->name);  //打印链表结点 
		temp = temp->next;  //指向下一个结点 
	}
	
	return 1;
} 

//撤销单链表
void Destroy(SLNode **head){
	//定义辅助指针 ,head暂时不能没有，故temp1指向head，temp2配合释放掉 
	SLNode *temp1 = NULL, *temp2 = NULL;
	
	//定义temp1辅助遍历 
	temp1 = *head;
	while(temp1 != NULL){  //最终：temp1 = NULL，temp2被释放 
		temp2 = temp1;   //temp2指向temp1，便于释放 
		temp1 = temp1->next;  //temp1指向下一个，避免链表丢失 
		free(temp2);  //释放temp2 
		temp2 = NULL;  //避免free都成为“野指针” 
	}
	*head = NULL;  //最后让head = NULL 
} 

//测试 
int main(int argc, char *argv[]) {
	SLNode *head;  //定义头指针变量
	SLNode *node1, *node2, *node3, *newnode;   //定义测试结点
	
	//初始化各结点
	ListInitiate(&head);
	ListInitiate(&node1);
	ListInitiate(&node2);
	ListInitiate(&node3);
	ListInitiate(&newnode);
	
	//定义各结点 
	node1->no = 1;
	strcpy(node1->name, "Lucy");
	node2->no = 2;
	strcpy(node2->name, "Jimy");
	node3->no = 3;
	strcpy(node3->name, "Zoma");
	newnode->no = 3;
	strcpy(newnode->name, "Candy");
	
	printf("当前数据个数：%d\n", ListLength(head));

/*	
	//测试插入链表尾部
	AddList(head, node1);
	printf("当前数据个数：%d\n", ListLength(head));
	AddList(head, node3);
	printf("当前数据个数：%d\n", ListLength(head));	
	AddList(head, node2);
	printf("当前数据个数：%d\n", ListLength(head));
*/

	//按照编号插入
	AddByOrder(head, node2);
	printf("当前数据个数：%d\n", ListLength(head));
	//测试插入一样编号的结点结果是否正确 
	AddByOrder(head, node2);
	printf("当前数据个数：%d\n", ListLength(head));
	AddByOrder(head, node1);
	printf("当前数据个数：%d\n", ListLength(head));
	AddByOrder(head, node3); 
	printf("当前数据个数：%d\n", ListLength(head));
	
	//显示链表
	printf("修改前链表信息如下：\n");
	ShowList(head);
	
	//测试修改结点信息
	UpdateNode(head, newnode); 
	
	//显示链表
	printf("修改后链表信息如下：\n");
	ShowList(head);
	
	//测试删除结点信息
	DelNode(head, 2); 
	
	//显示链表
	printf("删除后链表信息如下：\n");
	ShowList(head);
	
	//撤销单链表
	Destroy(&head);
	
	return 0;
}

本篇参考：

数据结构——使用C语言（第五版）

尚硅谷Java数据结构与java算法（Java数据结构与算法）

加啊啊啊啊零
关注
  • 5
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表-使用C语言实现带头结点的单链表.zip
03-13
链表 链表_使用C语言实现带头结点的单链表
c语言判断顺序链表是否为空,数据结构之线性表(五)——单链表(2 初始化，判断空表，销毁，清空，求表长)...
weixin_42522131的博客
05-21 4017
1.单链表(带头结点)的初始化即，构造一个空表，如下图， 算法步骤：1.生成新结点作头结点，用头指针L指向头结点。2.将头指针的指针域置空。算法描述：Status InitList_L(LinkList& L){L = new LNode; //在C语言里，为 L=(LinkList)malloc(sizeof(LNode));L->next = NULL;return OK;}...
头指针为head的带头结点的单链表判空条件head-＞next==null?
懵逼是一种状态的博客
07-21 1万+
由于考研需求，又乖乖滚回来捧起数据结构了，一年没碰书，忘得都差不多了，还得捡回来，哭死了。 进入正题，为何头指针为head的带头结点的单链表判空条件head->next==null?其实一开始这里也是没啥问题的，只是突然产生了疑问点——head为头指针，储存了头结点的地址，按照我残余的一点指针知识，我总感觉不对，head只是个地址，咋可以直接head->next使用呢？其实哈，这里又产生了和我之前学结构体这个知识点一样的纠结点（嘿嘿，其实这里也算是结构体类型）——结构体 总之和结构体类型一
单链表（带头结点）的存储结构与基本操作（c语言）------亲测可用
大学僧成长纪的博客
12-18 1万+
实现功能：单链表（带头结点）结点结构体的定义，单链表（带头结点）初始化、求元素个数、插入元素、删除元素、取元素、打印所有元素、就地逆置、撤销的操作。
单链表（带表头）的C语言实现（详细）
qq_983030560的博客
12-03 2969
单链表的C语言实现（详细）
C语言之单链表（带头结点）
qq_44887198的博客
11-13 2864
C语言之单链表（带头结点）一、思路步骤1. 定义结构体2.初始化3.求当前数据元素的个数4.插入5.删除6.释放内存空间二、代码 一、思路步骤 1. 定义结构体       a.数据域：用来存放数据       b.指针域：用来存放下一个数据的位置 2.初始化       申请头结点，并将其初始化为空 3.求当前数据元素的个数
数据结构-带头节点的单链表（C语言）超详细讲解
热门推荐
m0_56992713的博客
10-17 2万+
前面我们学到线性表的顺序存储结构（顺序表），发现它有着明显的缺点：插入和删除元素时需要频繁的移动元素，运算效率低。必须按事先估计的最大元素个数申请连续的存储空间。存储空间估计大了，造成浪费空间；估计小了，容易产生溢出，空间难以扩大。 采用链式存储结构的线性表（链表）可以克服以上的不足。 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(存放的数据元素)+指针(指示下一个元素存储位置，单、双链表的最后一个节点除外，它们.
【数据结构】【王道】【线性表】单链表的实现及基本操作（带头结点）（可直接运行）
treesorshining的博客
07-11 1667
1.2 初始化 1.3 判空 1.4 按位序插入 1.5 指定结点后插操作 1.6 指定结点前插操作 1.7 按位序删除 1.8 按位查找 1.9 按值查找 1.10 表的长度 1.11 单链表建立（尾插法） 1.12 单链表建立（头插法） 1.13 输出所有链表元素 2.完整代码 3.运行截图............
带头节点的单链表（C语言版）
zhu134的博客
05-12 1231
node表示是对结点的操作，*linkList是对整个链表的操作（注：linkList是Node*类型的）再创建一个结构体指针，指向头结点（不能直接指向l->next，要考虑空链表的情况）最后返回p（如果找到则返回p的地址，没找到则返回NULL，即遍历完还没找到）找到后让s结点指向指定结点前面的一个结点所指向的（即是指向指定位置的结点）（一定要先让s结点指向p结点的指向的结点，否则s结点就游离了）之后判定的条件是p！如果p不为空则打印p的数据再让p指向下一个结点。让前一个结点指向指定结点p所指向的结点。
带头结点的单链表的操作（C语言）
m0_61150341的博客
12-11 6217
初始化 带头结点的单链表 不带头节点的单链表 创建 头插法 尾插法 插入 删除 查找 输出
尾插法建立不带头结点的单链表(C语言).zip
04-17
本资源位课程设计希望对你有帮助
利用带头结点的单链表实现两个集合的并、交、差运算.docx
04-19
利用带头结点的单链表实现两个集合的并、交、差运算 1.题目重述 2.题目功能描述 3. 概要设计图 4. 程序源代码及注释 5. 流程图 6. 截图与数据分析 7.所采用的存储结构的优缺点及采用理由 8.实验心得体会
带头结点链表的各种操作（c语言）
10-26
/*在带头结点的单链表第i个位置后插入一个数*/ node *insert(node *head,int i,datatype x) { node *p,*q; q=find(head,i); if(!q) { printf("插入的位置不存在！\n");return head;} else { p=(node *)...
C语言实现单链表（带头结点）的基本操作
10-09
C语言实现单链表（带头结点）的基本操作 C语言实现单链表（带头结点）的基本操作 C语言实现单链表（带头结点）的基本操作 C语言实现单链表（带头结点）的基本操作
排序3——C语言
qq_74245477的博客
04-24 984
让每一个数都减去最小值，那么如果有负数，减去最小值（也是负数，可能是本身）之后的值肯定大于等于0，就可以满足数组的下标了。将序列分割，若子区间无序，对子区间再分割，直至子区间有序（只有一个数时）再进行合并（相当于合并两个有序数组）。不稳定，例子如下图，时间复杂度O（N*logN）空间复杂度O（logN）不稳定，例子如下图，时间复杂度O（N*logN）空间复杂度O（1）归并排序的缺点，空间复杂度为O（N），即额外需要一块辅助空间。不稳定，例子如下图，时间复杂度O（N^2）空间复杂度O（1）
C++高级特性：C/C++内存结构模型（十一）
weixin_43808717的博客
04-21 1277
代码段可制度数据段通常在程序加载时有操作系统加载到内存，一旦加载就不能被修改在函数调用时，函数的机器码也存储在代码段中，每个函数有其独特的代码段地址字符串常量等只读数据段中的数据是不可修改的，任何企图修改这些数据的尝试都会导致运行时错误作为一个专业的C++使用者来说，清楚的知道自己的代码变量存储的区域会有非常大的好处，补单能够写出高性能代码，而且有助于减少一些深层次的BUG。使用C++内存的一些注意事项内存泄漏：确保在动态分配内存后找个合适的时机释放掉，避免出现内存泄漏。
Day17.一刷数据结构算法(C语言版) 654最大二叉树；617合并二叉树；700二叉搜索树中的搜索；98验证二叉搜索树
m0_64336804的博客
04-22 1025
这里是c语言版数据结构算法。本期主题是：最大二叉树；合并二叉树；二叉搜索树中的搜索；验证二叉搜索树。
数据结构七：线性表之链式栈的设计
weixin_47040031的博客
04-27 605
从以上分析，我们可以知道链式栈只是单链表的一种特殊情况，限定了数据元素的插入和删除位置，链式栈是一种基于单链表实现的栈，在空间复杂度上，顺序栈在创建时就申请了数组空间，若栈经常处于不满状态将造成存储空间的浪费；链式栈所需空间是根据需要随时申请的，比之顺序栈仅仅是其每个结点需要额外的空间以存储其next指针域。在时间复杂度上，对于针对栈顶的基本操作（压入、弹出和栈顶元素存取），容易看出，顺序栈和链式栈的时间复杂性均为O(1)。
【数据结构】图的应用（最小生成树、拓扑排序、最短路径等）
最新发布
2201_75475240的博客
04-27 720
本文章介绍数据结构中的图的应用，包括最小生成树的Prim算法和Kruskal算法，拓扑排序和最短路径，且还包含408习题（附有解析）。此外，含有关于Prim算法，Kruskal算法和Dijkstra算法全部具体实现代码。
带头结点单链表删除x的c语言实现
07-27
以下是使用 C 语言实现删除带头结点单链表中元素 x 的代码： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构 struct ListNode { int val; struct ListNode* next; }; // 创建一个新节点 struct ListNode* createNode(int value) { struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode)); newNode->val = value; newNode->next = NULL; return newNode; } // 删除元素 x void deleteNode(struct ListNode* head, int x) { struct ListNode* pre = head; struct ListNode* current = head->next; while (current != NULL) { if (current->val == x) { pre->next = current->next; free(current); current = pre->next; } else { pre = current; current = current->next; } } } // 打印链表 void printList(struct ListNode* head) { struct ListNode* current = head->next; while (current != NULL) { printf("%d ", current->val); current = current->next; } printf("\n"); } int main() { // 创建头结点 struct ListNode* head = createNode(0); // 添加节点 head->next = createNode(1); head->next->next = createNode(2); head->next->next->next = createNode(3); int x = 2; // 要删除的元素 // 删除操作 deleteNode(head, x); // 打印删除操作后的链表 printList(head); return 0; } ``` 以上代码会输出删除元素 2 后的链表：0 -> 1 -> 3。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值