C：单项不循环链表的增删查改

已于 2023-11-18 23:20:31 修改
阅读量53 收藏
点赞数
文章标签： c语言 链表 开发语言
于 2023-11-18 23:19:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ghdfn/article/details/134484629
版权
本文详细介绍了链表的基本概念、节点结构，以及链表的后插、前插、后删、前删、查找、插入、删除等操作，并提供了完整代码示例。
摘要由CSDN通过智能技术生成

目录

1、链表的概念及结构

2、节点的概念

​3、链表的实现

4、链表后插

5、链表前插

6、链表后删

7、链表前删

8、查找链表中的某一个值

9、在pos节点前插入

10、删除pos节点 

11、在pos后插入节点

12、在pos后删除节点

13、销毁链表

完整代码

1、链表的概念及结构

        链表在物理结构上是不连续的，但是一般以逻辑结构上的连续来帮助理解。因为物理结构是不连续的，所以链表是用指针来进行操作，并且可以单独的释放和增加一个节点。

2、节点的概念

        链表是由一个个节点组成的，由于不同类型的链表，节点所包含的内容也不同，以单向链表为例。

typedef Struct Node
{
    int val; //节点中存储的值
    Struct Node* next; //指向下一个节点的指针，保存的是下一个节点的地址。
}Node；

上面的节点包含两个量，一个是节点中要存储的值，还有一个是下一个节点的地址，通过这个指针就可以访问下一个节点，这一样的节点一个个连起来，就成为了不带哨兵位的单向链表。

3、链表的实现

        想要创建一个链表，先从创建一个结构体指针和一个节点开始，让这个指针作为头指针，指向这个创建的节点。每个节点创建的时候都要进行初始化。

//创建一个节点并且初始化
SLNode* CreateNode(SLNDateType x)
{
    SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->val = x;
	return newnode;
}

之后每次进行插入节点的时候，都要调用创建节点的函数来创建一个新的节点。

4、链表后插

         链表后插就是从链表的最后进行插入节点。要注意的是，要先把新的节点的next指向原先节点的next、再把原先节点的next指向新的节点，否则就会出错。

//void SLTPushBack(SLNode** pphead, SLNDateType x)
//{
//	SLNode* newnode = CreateNode(x);
//	if (*pphead == NULL)//判断此时链表中是否为空
//	{
//		*pphead = newnode;//如果为空，就让头指针直接指向创建好的节点
//	}
//	else//如果不为空，那就找到链表的最后一个节点进行尾插操作。
//	{
//		SLNode* tail = *pphead;
//		while (tail->next != NULL)
//		{
//			tail = tail->next;
//		}
//		
//		tail->next = newnode;
//	}
//	
//}

此时要进行分情况讨论，因为插入节点的时候要进行指针的解引用，如果在链表中为空的情况下，对头指针进行解引用，就会造成非法访问。因为头指针只是一个指针，不是一个节点，在没有节点的时候，头指针就是空指针，不能进行解引用操作。 

5、链表前插

//void SLTPushFront(SLNode** pphead, SLNDateType x)
//{
//	SLNode* newnode = CreateNode(x);
//	newnode->next = *pphead;
//	*pphead = newnode;
//}

因为前插的时候，不涉及头指针的解引用操作，所以不需要进行判断。

6、链表后删

//void SLTPopBack(SLNode** pphead)
//{
//	assert(*pphead);//断言，当链表为空的时候不能执行删除操作
//	
//	if ((*pphead)->next == NULL)//判断是否只剩下一个节点，如果只剩下一个，就直接删掉。
//	{
//		free(*pphead);
//		*pphead = NULL;
//	}
//	else//否则找到尾节点，删掉最后一个节点，把前一个的next置空
//	{
//	SLNode* tail = *pphead;
//	while (tail->next->next != NULL)
//	{
//		tail = tail->next;
//	}
//	free(tail->next);
//	tail->next = NULL;
//	}
//}

 因为删除尾节点，是要找到最后一个节点删除，把前一个结点的next置空，所以是要找到倒数第一个和倒数第二个节点，所以链表后删同样有可能出现头指针解引用的情况，所以当只剩下一个节点的时候，要单独处理。

7、链表前删

//void SLTPopFront(SLNode** pphead)
//{
//	assert(*pphead);
//	SLNode* tmp = (*pphead)->next;
//	free(*pphead);
//	*pphead = tmp;
//}

8、查找链表中的某一个值

//SLNode* SLTFind(SLNode* phead, SLNDateType x)
//{
//	SLNode* cur = phead;
//	while (cur)
//	{
//		if (cur->val == x)
//		{
//			return cur;
//		}
//		cur = cur->next;
//	}
//	return NULL;
//}

当找到这个值的时候，返回的是这个值所在节点的地址。 

9、在pos节点前插入

这个节点是要配合查找节点使用，找到一个值所在的节点地址之后，在这个节点前进行插入。

在pos前插入
//void SLTInsert(SLNode** pphead, SLNode* pos, SLNDateType x)
//{
//	assert(pphead);
//	assert((!pos && !(*pphead))||(pos && (*pphead)));
//	
//	
//	if (*pphead == pos)//如果找到的位置是第一个节点，那就直接执行前插操作。
//	{
//		SLTPushFront(pphead, x);
//		/*newnode->next = *pphead;
//		*pphead = newnode;*/
//	}
//	else
//	{
//		SLNode* newnode = CreateNode(x);
//		SLNode* cur = *pphead;
//		while (cur->next != pos)
//		{
//			cur = cur->next;
//		}
//
//		newnode->next = cur->next;
//		cur->next = newnode;
//	}
//	
//}

10、删除pos节点 

同样，要使用查找函数，使用返回的节点地址进行操作。

pos删除
//void SLTErase(SLNode** pphead, SLNode* pos)
//{
//	assert(*pphead);
//	assert(pos);
//	SLNode* cur = *pphead;
//	if (*pphead == pos)如果要铲除的是第一个节点，那就直接执行头删操作
//	{
//		/**pphead = pos->next;
//		pos = NULL;
//		free(pos);*/
//		SLTPopFront(pphead);
//	}
//	else
//	{
//		while (cur->next != pos)
//		{
//			cur = cur->next;
//		}
//		cur->next = pos->next;
//		pos = NULL;
//		free(pos);
//	}

11、在pos后插入节点

pos后插
//void SLTInsertSfter(SLNode* pos, SLNDateType x)
//{
//	assert(pos);
//	SLNode* newnode = CreateNode(x);
//	newnode->next = pos->next;
//	pos->next = newnode;
//
//}

 12、在pos后删除节点

pos后删
//void SLTEraseAfter(SLNode* pos)
//{
//	assert(pos);
//	assert(pos->next);
//	SLNode* tmp = pos->next;
//	pos->next = pos->next->next;
//	free(tmp);
//	tmp = NULL;
//}

13、销毁链表

销毁链表
//void Distory(SLNode** pphead)
//{
//	SLNode* cur = *pphead;
//	while (cur!=NULL)
//	{
//		SLNode* tmp = cur;
//		cur = cur->next;
//		free(tmp);
//		tmp = NULL;
//	}
//	*pphead = NULL;
//}

完整代码

SList.h

//#define _CRT_SECURE_NO_WARNINGS 1
//#pragma once
//#include<stdio.h>
//#include<stdlib.h>
//#include<assert.h>
//
//typedef int SLNDateType;
//
//
Single LIst
//typedef struct SListNode
//{
//	SLNDateType val;
//	struct SListNode* next;
//}SLNode;
//
打印
//void SLTPrint(SLNode* phead);
后插
//void SLTPushBack(SLNode** pphead, SLNDateType x);
前插
//void SLTPushFront(SLNode** pphead, SLNDateType x);
后删
//void SLTPopBack(SLNode** pphead);
前删
//void SLTPopFront(SLNode** pphead);
查找
//SLNode* SLTFind(SLNode* pphead, SLNDateType x);
pos前插入
//void SLTInsert(SLNode** pphead, SLNode* pos, SLNDateType x);
pos删除
//void SLTErase(SLNode** pphead, SLNode* pos);
pos后插入
//void SLTInsertSfter(SLNode* pos, SLNDateType x);
pos后删除
//void SLTEraseAfter(SLNode* pos);
销毁链表
//void Distory(SLNode** pphead);

SList.c 

//#include"SList.h"
//
//void SLTPrint(SLNode* phead)
//{
//	SLNode* cur = phead;
//	while (cur!=NULL)
//	{
//		printf("%d->", cur->val);
//		cur = cur->next;
//	}
//	printf("null\n");
//}
//
//SLNode* CreateNode(SLNDateType x)
//{
//	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
//	if (newnode == NULL)
//	{
//		perror("malloc fail");
//		exit(-1);
//	}
//	newnode->next = NULL;
//	newnode->val = x;
//	return newnode;
//}
//
后插
//void SLTPushBack(SLNode** pphead, SLNDateType x)
//{
//	SLNode* newnode = CreateNode(x);
//	if (*pphead == NULL)
//	{
//		*pphead = newnode;
//	}
//	else
//	{
//		SLNode* tail = *pphead;
//		while (tail->next != NULL)
//		{
//			tail = tail->next;
//		}
//		
//		tail->next = newnode;
//	}
//	
//}
//
前插
//void SLTPushFront(SLNode** pphead, SLNDateType x)
//{
//	SLNode* newnode = CreateNode(x);
//	newnode->next = *pphead;
//	*pphead = newnode;
//}
//
后删
//void SLTPopBack(SLNode** pphead)
//{
//	assert(*pphead);
//	
//	if ((*pphead)->next == NULL)
//	{
//		free(*pphead);
//		*pphead = NULL;
//	}
//	else
//	{
//	    SLNode* tail = *pphead;
//	    while (tail->next->next != NULL)
//	{
//		tail = tail->next;
//	}
//	    free(tail->next);
//	    tail->next = NULL;
//	}
//}
//
前删
//void SLTPopFront(SLNode** pphead)
//{
//	assert(*pphead);
//	SLNode* tmp = (*pphead)->next;
//	free(*pphead);
//	*pphead = tmp;
//	//错误写法
//	/*SLNode* tmp = *pphead;
//	free(tmp);
//	*pphead = (*pphead)->next;*/
//}
//
查找
//SLNode* SLTFind(SLNode* phead, SLNDateType x)
//{
//	SLNode* cur = phead;
//	while (cur)
//	{
//		if (cur->val == x)
//		{
//			return cur;
//		}
//		cur = cur->next;
//	}
//	return NULL;
//}
//
在pos前插入
//void SLTInsert(SLNode** pphead, SLNode* pos, SLNDateType x)
//{
//	assert(pphead);
//	assert((!pos && !(*pphead))||(pos && (*pphead)));
//	
//	
//	if (*pphead == pos)
//	{
//		SLTPushFront(pphead, x);
//		/*newnode->next = *pphead;
//		*pphead = newnode;*/
//	}
//	else
//	{
//		SLNode* newnode = CreateNode(x);
//		SLNode* cur = *pphead;
//		while (cur->next != pos)
//		{
//			cur = cur->next;
//		}
//
//		newnode->next = cur->next;
//		cur->next = newnode;
//	}
//	
//}
//
pos删除
//void SLTErase(SLNode** pphead, SLNode* pos)
//{
//	assert(*pphead);
//	assert(pos);
//	SLNode* cur = *pphead;
//	if (*pphead == pos)
//	{
//		/**pphead = pos->next;
//		pos = NULL;
//		free(pos);*/
//		SLTPopFront(pphead);
//	}
//	else
//	{
//		while (cur->next != pos)
//		{
//			cur = cur->next;
//		}
//		cur->next = pos->next;
//		pos = NULL;
//		free(pos);
//	}
//	
//}
//
pos后插
//void SLTInsertSfter(SLNode* pos, SLNDateType x)
//{
//	assert(pos);
//	SLNode* newnode = CreateNode(x);
//	newnode->next = pos->next;
//	pos->next = newnode;
//
//}
//
pos后删
//void SLTEraseAfter(SLNode* pos)
//{
//	assert(pos);
//	assert(pos->next);
//	SLNode* tmp = pos->next;
//	pos->next = pos->next->next;
//	free(tmp);
//	tmp = NULL;
//}
//
销毁链表
//void Distory(SLNode** pphead)
//{
//	SLNode* cur = *pphead;
//	while (cur!=NULL)
//	{
//		SLNode* tmp = cur;
//		cur = cur->next;
//		free(tmp);
//		tmp = NULL;
//	}
//	*pphead = NULL;
//}

Test.c

//#include"SList.h"
//
//void Test()
//{
//	SLNode* plist = NULL;
//	SLTPushBack(&plist, 1);
//	SLTPushBack(&plist, 2);
//	SLTPushBack(&plist, 3);
//	SLTPrint(plist);
//	//SLTPopFront(&plist);
//	SLNode* findpos = SLTFind(plist, 1);
//	SLTErase(&plist, findpos);
//	//SLTInsert(&plist, findpos, 4);
//	SLTPrint(plist);
//	//SLTPopBack(&plist);
//	//SLTPrint(plist);
//	Distory(&plist);
//}
//
//int main()
//{
//	Test();
//	return 0;
//}

菲利普赵
关注
C语言实现删除单向不循环链表重复节点
weixin_44587314的博客
05-06 364
预置条件 typedef struct link_list { int data; struct link_list* next; }LINK_NODE; //定义一个链表节点，包含数据属性data，和指向该结构体的指针netx 1.删除重复节点（只保留第一个重复的节点） LINK_NODE* del_repetition(LINK_NODE* phead) { /* 删除链表中的重复元...
单链表中如何快速删除p指向的节点？（ 简单方法：复杂度为O（1） ）
deniece1的博客
09-15 8317
问题： 只知道指针P指向一个单向非循环链表的节点，不是头节点也不是尾节点，从链表上把 P指向的节点删除… 思路： 一般的思路是要遍历链表找到节点P的前驱节点， 然后再删掉节点P， 但是这样效率不是很高， 可以换个思路， P节点的后继节点是可以在O(1) 复杂度下得到的， 可以将P的后继节点的数据复制到P节点中， 然后删掉P的后继节点， 重新接链即可… 实现如下： temp = p->next...
数据结构：单向链表(SingleLinkedList)删除某一节点
Chris_Hango的博客
05-21 446
定义一个简单的单向链表节点 public class ListNode { int value; ListNode next; ListNode(int x) { val = x;} } 思路一 //将前一节点的next直接指向后一节点 思路二 //将后一节点的值赋给要删除的节点，将此节点的next指向后一节点的后一节点 public void deleteNode(ListNode node) { node.value = node.next.value; node.next =
删除单向链表中的节点
qq_43164662的博客
02-21 6003
在单链表中只给定需要删除的节点（非尾节点），如何删除该节点，而且不断链。
【机试题(实现语言：python3)】从单向列表中删除指定值的节点----列表操作
qq_35061334的博客
05-18 413
题目描述 输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。 链表的值不能重复。 构造过程，例如输入一行数据为: 6 2 1 2 3 2 5 1 4 5 7 2 2 则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示: 1 2 表示为 2->1 链表为2->1 3 2表示为 2->3 链表为2->3->1 5 1表示为 1->5 链表为2-&gt
单向循环链表：增删改查
m0_61401170的博客
01-10 189
单向循环链表 数据结构 函数指针运用 c语言
C语言 单链表的增删改查
weixin_45747214的博客
05-08 720
单链表的增删改查 目录单链表的增删改查链表的创建和输出（有头结点）链表的查找链表的删除链表的修改 链表是一种最常见地采用动态存储分配方式的数据结构，相较于数组而言它更加灵活。 单链表的特点 有一个head指针变量，他存放第一个结点的地址，称之为“头指针”。 每个结点都包含一个数据域和一个指针域，数据域存放用户需要的实际数据，指针域存放下一个结点的地址。从头结点开始，每一个结点的指针域都指向下一个结点，所有结点都是单线联系。 最后一个节点不再指向其他节点，成为“表尾”结点，它的指针域为空指针“NULL”
C语言如何建立链表并实现增删查改详解
01-01
以下是本人完成的一个C语言建立链表并进行增删查改操作的程序，为方便学习，本人将整个程序分为头文件和主函数两部分： 1.头文件(函数部分) (1)初始化函数 #include #include typedef struct { int *head; int...
链表的增删查改.rar
05-14
链表的增删查改操作是数据结构学习的基础，掌握这些操作有助于理解和解决更复杂的数据结构问题，如二叉树、图等。同时，链表也是许多高级数据结构（如队列、栈、哈希表）的基础，因此，对链表的熟练掌握是成为一名...
双向循环链表、增删查改、判断回文、排序、论文+代码
07-25
双向循环链表、增删查改、判断回文、排序、论文＋代码 本资源摘要信息主要针对数据结构与算法课程设计，涵盖双向循环链表、增删查改、判断回文、排序等知识点。下面将对每个知识点进行详细的解释和分析。 一、双向...
家庭账本，链表的增删查改
03-16
利用结构体数组和链表完成增删查改，包括统计个人支出和整月支出，按日期支出等功能。没有特别复杂的数据结构，适合刚学习结构体和链表的学生练手。
删除单向链表中的某个节点
热门推荐
cchengone的博客
10-30 1万+
题目：Delete Node in a linked List描述：Write a function to delete a node (except the tail) in a singly linked list, given only access to that node. Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are
C语言：结构体变量
2302_80978287的博客
09-16 275
设有30个学生，每个人都有学号、姓名和考试成绩三项数据，从键盘输入这些数据，找出成绩最高者并输出其数据。与普通变量一样，结构体变量也可以通过指针变量来间接访问。
二十种编程语言庆祝中秋节
敲代码别忘了喝上一杯凉白开。
09-17 975
在全球范围内，编程语言作为技术沟通的桥梁，不仅仅局限于解决技术问题，还能承载文化传递的使命。本文展示了如何使用二十种不同的编程语言来表达对中秋节的祝福，这些语言包括了Python、C、C++、Java、C#、Perl、Go、ASP、PHP、JavaScript、HTML、Visual Basic、VB早期版本、Visual C++、Delphi、Shell、Cobol、ActionScript、Foxpro和DOS批处理。每种语言的代码示例简单直接，都以其独特的语法输出“祝大家中秋快乐”的信息。
report ETL .ffff
09-17
report ETL .ffff
基于ssm的共享充电宝管理系统设计与实现.docx
09-17
基于ssm的共享充电宝管理系统设计与实现.docx
操作系统大作业_Linux_命令行_OSWork.zip
最新发布
09-17
操作系统大作业_Linux_命令行_OSWork
Java项目-基于SSM+Jsp的社区管理与服务系统的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的社区管理与服务系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的社区管理与服务系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
吉他谱_Show Me How To Live - Audioslave.pdf
09-17
初级入门吉他谱 guitar tab
单项循环链表解决约瑟夫环
08-22
对于解决约瑟夫环问题，使用单项循环链表可以是一种有效的方法。下面是一种基本的算法实现： 1. 首，我们需要创建一个单向循环链，其中每个节点存储一个值和指向下一个节点的指针。 2. 接下来，我们需要确定首个节点和尾节点，并将尾节点的指针指向首个节点，形成循环。 3. 然后，我们需要选择一个起始点，通常是第一个节点，并设定一个计数器变量。 4. 接着，我们开始循环遍历链表，每次遍历计数器加1。 5. 当计数器的值等于给定的步长（表示要跳过的人数）时，我们就找到了要删除的节点。 6. 我们将删除该节点，并将上一个节点的指针指向下一个节点，从而绕过被删除的节点。 7. 然后，重置计数器并继续遍历链表，直到只剩下最后一个节点为止。 8. 最后，我们得到了最后一个幸存者的位置。 这种方法利用循环链表的特性，通过不断跳过一定数量的节点来模拟约瑟夫环的过程，并最终找到最后一个幸存者的位置。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菲利普赵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值