C语言单链表的实现(增删改查)

最新推荐文章于 2024-05-28 16:27:35 发布
最新推荐文章于 2024-05-28 16:27:35 发布
阅读量1.1w 收藏 75
点赞数 19
分类专栏： C语言 文章标签： C 单向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33706673/article/details/84944845
版权

 

链表的基础可以参考：https：//blog.csdn.net/morixinguan/article/details/68951912

或者参考：https：//blog.csdn.net/Hackbuteer1/article/details/6591486

 

说明：这篇文章是自己理解然后熟悉时的学习笔记，主要记录实现过程中的代码笔记，以备日后快速查询，仅供参考：

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

//创建一个结构体表示链表中的节点
typedef struct node
{
	struct node *link;//指针域，注意这里类型是node，而不是T_NODE
	int var;//数据域
}T_NODE;

//初始化一个链表，并将第一个值传入(有的实现头结点不插入数据,自己选择)
T_NODE *list_init(int var)
{
	//创建根节点
	T_NODE *head = (T_NODE *)malloc(sizeof(T_NODE));
	if(NULL == head)
	{
		printf("错误。申请内存失败，创建节点失败\n");
		exit(1);
	}
	
	//初始化头节点
	head->var = var;
	head->link = NULL;
	
	return head;
}

void print_list(    T_NODE *list_head)
{
	int i =  0;
	if(NULL == list_head)
	{
		printf("链表为空\n");
	}

	//指针域为NULL，表示这是最后一个节点，但是该节点是有效节点，所以这里用do while
	do 
	{
		printf("链表节点%d的值是：%d\n",++i,list_head->var);
		list_head = list_head->link;
	}while(list_head);
}

//计算链表的长度
int list_lenth(T_NODE *list_head)
{
	int lenth = 0;
	while(list_head)
	{
		lenth++;
		list_head = list_head->link;
	}
	return lenth;
}

//单个数据插入，尾插法
int list_tail_insert(T_NODE *list_head,int var)
{
	T_NODE *list_new_node = (T_NODE *)malloc(sizeof(T_NODE));
	if(NULL == list_new_node)
	{
		printf("error,malloc failed\n");
		return -1;
	}

	while(list_head->link)
	{
		list_head = list_head->link;
	}
	
	list_new_node->var = var;//将值给该节点，并将上一个节点的指针域指向该节点地址
	list_new_node->link = NULL;
	list_head->link = list_new_node;

	return 0;
}

//单个数据插入，头插法
T_NODE *list_head_insert(T_NODE *list_head,int var)
{
	T_NODE *list_new_node = (T_NODE *)malloc(sizeof(T_NODE));

	if(NULL == list_new_node)
	{
		printf("error,malloc failed\n");
		return NULL;
	}

	list_new_node->link = list_head;
	list_new_node->var = var;
	list_head = list_new_node;
	
	return list_head;
}

//指定位置插入,可以插入头，尾，或者头尾之间任意位置
T_NODE *list_specific_insert(T_NODE *list_head,int location,int var)
{
	int len = list_lenth(list_head);
	int i = 1;//为保持人的习惯，第1个位置表示1而不是0
	T_NODE *node_last = NULL;
	T_NODE *node_temp = list_head;
	
	//位置是1，插在链表的开头，用头插法
	if(1 == location)
	{
		list_head = list_head_insert(list_head, var);
		return list_head;
	}

	//位置比链表长度大1，插在链表尾部
	if((len + 1 ) == location)
	{
		list_tail_insert(list_head, var);
		return list_head;
	}

	//指定的位置最大是链表长度加1，location=1表示头，location=len+1，表示插在尾部
	if((location > (len + 1)) ||(location < 1))
	{
		printf("插入失败。请检查链表长度，指定插入位置不对\n");
		return list_head;
	}
	
	//这里采用头插法插入，也可以采用尾插法
	while(i < location)
	{
		node_last = node_temp;
		node_temp = node_temp->link;
		i++;
	}
	
	node_temp = list_head_insert(node_temp, var);
	node_last->link = node_temp;
	
	return list_head;
}

//从链表头开始删除整个链表
T_NODE *del_list(T_NODE *list_head)
{
	T_NODE *node_temp = (T_NODE *)malloc(sizeof(T_NODE));
	if(NULL == node_temp)
	{
		printf("error.%s:%d. malloc error\n",__FUNCTION__,__LINE__);
	}
	
	while(list_head->link)
	{
		node_temp = list_head->link;
		free(list_head);
		list_head = node_temp;
	}
	free(list_head);
	
	printf("整个删除链表成功\n");

	return NULL;
}

//修改链表中的指定元素值
void change_specific_var(T_NODE *list_head,int old_var,int new_var)
{
	while (NULL != list_head)
	{
		if(old_var == list_head->var)
		{
			list_head->var = new_var;
			printf("将%d修改为%d成功\n",old_var,new_var);
			return;
		}
		list_head = list_head->link;
	}
	printf("将%d修改为%d失败\n",old_var,new_var);
}

//删除链表中的指定元素值
T_NODE * del_specific_var(T_NODE *list_head,int del_var)
{
	T_NODE *list_temp = NULL;
	T_NODE *list_head_temp = list_head;
	
	while(NULL != list_head)
	{
		if(del_var == list_head->var)
		{
			//如果删除的是头结点
			if(NULL == list_temp)
			{	
				list_temp = list_head;
				list_head = list_head->link;
				free(list_temp);
				
				return list_head;
			}
			else//删除的不是头结点
			{
				list_temp->link = list_head->link;
				free(list_head);
				return list_head_temp;
			}
		}
		list_temp = list_head;
		list_head = list_head->link;
	}
	return list_head_temp;
}

//测试头插法
T_NODE *test_head_insert(T_NODE *list_head,int arr[])
{
	int i;
	//头插法，头结点已经初始化，从第二个开始加入链表
	for(i = 1; i < 6; i++)
	{
		list_head = list_head_insert(list_head, arr[i]);
	}
	printf("测试头插法，链表的长度是%d\n",list_lenth(list_head));
	print_list(list_head);

	return list_head;
}

//测试尾插法
void test_tail_insert(T_NODE *list_head,int arr[])
{
	int i;
	for(i = 1; i < 6; i++)
	{
		list_tail_insert(list_head, arr[i]);
	}
	printf("\n测试尾插法，链表的长度是%d\n",list_lenth(list_head));
	print_list(list_head);
}

//测试指定位置插入
T_NODE *test_specific_insert(T_NODE *list_head)
{
	int len = 0;
	//测试头尾之间插入节点
	printf("\n开始测试指定位置插入-->-->-->-->-->-->\n");

	printf("链表第4个节点插入数据4。。。\n");
	list_head = list_specific_insert(list_head, 4, 4);
	printf("操作完成后链表长度%d\n",list_lenth(list_head));
	print_list(list_head);

	
	printf("\n链表第1个节点插入数据100。。。\n");
	list_head = list_specific_insert(list_head, 1, 100 );
	printf("操作完成后链表长度%d\n",list_lenth(list_head));
	print_list(list_head);

	len = list_lenth(list_head);
	printf("\n链表第%d个节点插入数据%d。。。\n",len + 1,len + 1);
	list_head = list_specific_insert(list_head, (list_lenth(list_head) + 1), (list_lenth(list_head) + 1));
	printf("操作完成后链表长度%d\n",list_lenth(list_head));
	print_list(list_head);

	printf("\n链表第0个节点插入数据200。。。\n");
	list_head = list_specific_insert(list_head, 0, 200);
	printf("操作完成后链表长度%d\n",list_lenth(list_head));
	print_list(list_head);

	printf("\n链表第20个节点插入数据20。。。\n");
	list_head = list_specific_insert(list_head, 20, 20);
	printf("操作完成后链表长度%d\n",list_lenth(list_head));
	print_list(list_head);

	printf("-->-->-->-->-->-->结束测试指定位置插入\n");
	return list_head;
}
void test_change_specific_var(T_NODE *list_head)
{
	printf("\n开始测试修改指定值-->-->-->-->-->-->\n");
	printf("将4替换成5。。。\n");
	change_specific_var(list_head, 4, 5);
	print_list(list_head);

	printf("\n将666替换成888。。。\n");
	change_specific_var(list_head, 666, 888);
	print_list(list_head);

	printf("\n将100替换成888。。。\n");
	change_specific_var(list_head, 100, 888);
	print_list(list_head);
	printf("-->-->-->-->-->-->结束测试修改指定值\n");
}
T_NODE* test_del_specific_var(T_NODE *list_head)
{
	printf("\n开始测试删除指定值-->-->-->-->-->-->\n");
	printf("将5删除。。。\n");
	list_head = del_specific_var(list_head,5);
	print_list(list_head);

	printf("\n将888删除。。。\n");
	list_head = del_specific_var(list_head, 888);
	print_list(list_head);

	printf("\n将9删除。。。\n");
	list_head = del_specific_var(list_head,9);
	print_list(list_head);
	printf("-->-->-->-->-->-->结束测试删除指定值\n");
}

int main(void)
{
	T_NODE *head;//存储一个链表的头节点地址
	//T_NODE *new_node;//存储新创建节点的地址
	//T_NODE *temp;//存储操作过程中移动节点的地址
	
	int arr[6] = {1,2,3,6,7,8};//假设需要存储的是这5个数
	//int i = 0;//循环变量

	head = list_init(arr[0]);//初始化或者创建一个链表头结点
	head = test_head_insert(head, arr);//测试头插法
	del_list(head);//删除链表

	head = list_init(arr[0]);//初始化或者创建一个链表头结点
	test_tail_insert(head, arr);//测试尾插法

	head = test_specific_insert(head);//测试指定位置插入

	test_change_specific_var(head);//测试指定值替换
	head = test_del_specific_var(head);//测试删除指定值

	
	return 0;
}

 运行结果：

测试头插法，链表的长度是6
链表节点1的值是：8
链表节点2的值是：7
链表节点3的值是：6
链表节点4的值是：3
链表节点5的值是：2
链表节点6的值是：1
整个删除链表成功

测试尾插法，链表的长度是6
链表节点1的值是：1
链表节点2的值是：2
链表节点3的值是：3
链表节点4的值是：6
链表节点5的值是：7
链表节点6的值是：8

开始测试指定位置插入-->-->-->-->-->-->
链表第4个节点插入数据4。。。
操作完成后链表长度7
链表节点1的值是：1
链表节点2的值是：2
链表节点3的值是：3
链表节点4的值是：4
链表节点5的值是：6
链表节点6的值是：7
链表节点7的值是：8

链表第1个节点插入数据100。。。
操作完成后链表长度8
链表节点1的值是：100
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：4
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8

链表第9个节点插入数据9。。。
操作完成后链表长度9
链表节点1的值是：100
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：4
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8
链表节点9的值是：9

链表第0个节点插入数据200。。。
插入失败。请检查链表长度，指定插入位置不对
操作完成后链表长度9
链表节点1的值是：100
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：4
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8
链表节点9的值是：9

链表第20个节点插入数据20。。。
插入失败。请检查链表长度，指定插入位置不对
操作完成后链表长度9
链表节点1的值是：100
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：4
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8
链表节点9的值是：9
-->-->-->-->-->-->结束测试指定位置插入

开始测试修改指定值-->-->-->-->-->-->
将4替换成5。。。
将4修改为5成功
链表节点1的值是：100
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：5
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8
链表节点9的值是：9

将666替换成888。。。
将666修改为888失败
链表节点1的值是：100
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：5
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8
链表节点9的值是：9

将100替换成888。。。
将100修改为888成功
链表节点1的值是：888
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：5
链表节点6的值是：6
链表节点7的值是：7
链表节点8的值是：8
链表节点9的值是：9
-->-->-->-->-->-->结束测试修改指定值

开始测试删除指定值-->-->-->-->-->-->
将5删除。。。
链表节点1的值是：888
链表节点2的值是：1
链表节点3的值是：2
链表节点4的值是：3
链表节点5的值是：6
链表节点6的值是：7
链表节点7的值是：8
链表节点8的值是：9

将888删除。。。
链表节点1的值是：1
链表节点2的值是：2
链表节点3的值是：3
链表节点4的值是：6
链表节点5的值是：7
链表节点6的值是：8
链表节点7的值是：9

将9删除。。。
链表节点1的值是：1
链表节点2的值是：2
链表节点3的值是：3
链表节点4的值是：6
链表节点5的值是：7
链表节点6的值是：8
-->-->-->-->-->-->结束测试删除指定值

 

行者三个石
关注
  • 19
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言实现单链表-增删改查.pdf
02-16
链表可以在头部和尾部插入和删除节点，因此可以在任何地方插入和删除节点，从而使其变得灵活和易于实现。 链表通常用于实现有序集合，例如队列和双向链表。链表的优点是可以快速随机访问节点，而缺点是插入和删除...
c语言 单链表的增删改查
04-25
C语言编写的单链表增删改查，实现了单链表的增加，删除，修改，查询等功能
数据结构-单链表的增删改查
m0_62159976的博客
04-28 154
测试函数的功能时最好写成test函数形式，不要写成菜单形式，便于调试。
【数据结构】—— 单链表的增删改查
周小末天天开心的博客
11-22 1790
单链表的创建、删除、更改、查看
单向链表的C语言实现
最新发布
Broken_x的博客
05-28 1024
首先，我们需要定义单向链表的结点和链表本身的结构// 单向链表的结点定义// 数据域// 指针域，指向后继结点} Listnode;// 单向链表的定义// 头结点// 整个链表的元素个数和：包含标准输入输出和标准库函数。：定义链表中数据的类型为int，可以根据需要更改。：定义链表结点结构体，包含数据域data和指向后继结点的指针next。：定义链表结构体，包含指向头结点的指针head和链表的元素个数size。
单链表（增删查改）
weixin_70056514的博客
03-07 852
单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。简单来说单链表就是一个一个的节点链接起来的链式结构，每个节点里面存储着一个数据和与它链接的下一个节点的（指针）地址。（注意，每一个节点都是同一种结构体类型）
单链表增删查改查
wh9109的博客
03-12 203
单链表
C语言——单链表实现学生信息的增删改查！！
qq_60331192的博客
12-04 3920
单链表实现的小功能！ 3.输入学生信息 4.输出学生信息 5.查询指定学生信息 6.插入学生信息 7.修改学生信息 8.删除学生信息 9.退出 10.主函数 11.完整代码 12.效果展示 主界面展示：
单链表c语言实现增删改查操作
09-21
这个项目"单链表c语言实现增删改查操作"是基于VS2008运行环境，用C语言编程实现对单链表的基本操作，包括插入、删除、修改和查询元素，并将结果输出到控制台。 首先，我们需要定义链表的节点结构： ```c typedef ...
C语言数据结构单链表的增删改查
05-27
在这个主题中，我们将深入探讨"单链表"这种基本的数据结构以及在C语言中如何进行增删改查的操作。 单链表是一种线性数据结构，其中的元素（节点）通过指向下一个元素的指针连接在一起。每个节点包含两部分：数据域...
单链表的增删改查.c
06-18
链表是一种常见的数据结构，资源包含了我对单链表的增删改查实现，本资源是不带头结点的单链表的增删改查，个人能力有限，希望指出不足之处，与大家共勉
C语言单链表实现完全详解
01-13
C语言单链表实现完全详解,想把数据结构里面涉及的都自己实现一下，完全是用C语言实现的
通用数据类型链表C语言实现
qq_33471732的博客
03-10 412
该代码首先初始化了一个空的链表，然后向其添加了一个整型、一个浮点型和一个字符型数据。随后遍历了链表并打印了每个节点的数据。之后，删除了头节点并重新遍历了链表，打印出了剩余节点的数据。通用链表是一种动态内存分配的数据结构，其中每个节点包含一个指向下一个节点的指针和一个指向任意类型数据的指针。因此，通用链表可以容纳任意类型的数据，这是其与其他数据结构不同的地方。其中，head指向链表头，tail指向链表尾，size为链表节点数。其中，data指向任意类型的数据，next指向下一个节点。
链表编程（C语言）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
02-17 670
1.带头结点单链表 结点类型描述 基本操作定义 基本操作实现 其他操作（交集，差集，合并，逆置，排序） 2.不带头结点单链栈 结点类型描述 基本操作定义 基本操作实现 3.循环单链表 结点类型描述 基本操作定义 基本操作实现 4.循环双链表 结点类型描述 基本操作定义 基本操作实现
单链表（C语言实现）
cw412524的博客
11-20 1764
数据结构单链表（C语言实现），干货满满！
【数据结构】---单链表【C语言实现】
mike_jun的博客
07-10 4206
1. 单向链表 我们都熟悉数组，它作为一个顺序储存方式数据结构为我们的程序设计带来了大量的便利，几乎任何的高级程序设计，算法设计都离不开数组的灵活使用。 但是，数组最大的缺点就是我们的插入和删除时需要移动大量的元素，显然这需要消耗大量的时间。 数组找到指定元素很快，O（1）复杂度就可以，而链表只能是遍历，O(n)的复杂度。 数组是顺序存储的，链表是通过指针实现不连续的存储 相比起数组，链表解决了数组不方便移动，插入，删除元素的弊端，但相应的，链表付出了更加大的内存牺牲换来的这些功能的实现。 ...
用C语言实现单链表操作
xuzhougeng blog
02-02 6596
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
C语言实现单链表的简单操作【完整版】
魏尔肖的博客
03-19 1398
#ifndef __LIST__H_ #define __LIST__H_ typedef int DataType; typedef unsigned int size_t; typedef struct Node { DataType _data; struct Node *_pNext; }Node, *PNode; void InitList(PNode* pHead)
单链表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 2万+
本文介绍单链表的定义、常用操作、优化和使用的注意点等内容。
c语言单链表的增删改查代码
06-06
好的，以下是 C 语言单链表的增删改查代码： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构体 struct Node { int data; struct Node* next; }; // 定义链表头节点指针 struct Node* head = NULL; // 插入节点函数 void insertNode(int data) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->next = NULL; if (head == NULL) { head = newNode; } else { struct Node* temp = head; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } printf("插入节点成功！\n"); } // 删除节点函数 void deleteNode(int data) { if (head == NULL) { printf("链表为空，无法删除！\n"); return; } struct Node* temp = head; if (temp->data == data) { head = head->next; free(temp); printf("删除节点成功！\n"); return; } while (temp->next != NULL && temp->next->data != data) { temp = temp->next; } if (temp->next == NULL) { printf("未找到要删除的节点！\n"); return; } struct Node* deleteNode = temp->next; temp->next = deleteNode->next; free(deleteNode); printf("删除节点成功！\n"); } // 修改节点函数 void modifyNode(int data, int newData) { if (head == NULL) { printf("链表为空，无法修改！\n"); return; } struct Node* temp = head; while (temp != NULL && temp->data != data) { temp = temp->next; } if (temp == NULL) { printf("未找到要修改的节点！\n"); return; } temp->data = newData; printf("修改节点成功！\n"); } // 查找节点函数 void searchNode(int data) { if (head == NULL) { printf("链表为空，无法查找！\n"); return; } struct Node* temp = head; while (temp != NULL && temp->data != data) { temp = temp->next; } if (temp == NULL) { printf("未找到要查找的节点！\n"); return; } printf("找到要查找的节点，数据为：%d\n", temp->data); } // 打印链表函数 void printList() { if (head == NULL) { printf("链表为空，无法打印！\n"); return; } struct Node* temp = head; printf("链表中的节点数据为："); while (temp != NULL) { printf("%d ", temp->data); temp = temp->next; } printf("\n"); } int main() { insertNode(1); insertNode(2); insertNode(3); printList(); modifyNode(2, 4); printList(); searchNode(3); deleteNode(2); printList(); return 0; } ``` 以上是单链表的基本操作函数，包括插入节点、删除节点、修改节点、查找节点以及打印链表等功能。你可以根据需要进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值