考研数据结构单链表的增删改查看这一篇就够了

已于 2023-11-14 19:13:20 修改
阅读量428 收藏 1
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构 c语言 考研
于 2023-11-11 22:33:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62830324/article/details/134347128
版权

目录

一. 单链表的特点

1.1 解引用拓展 🤖

二. 单链表的操作

2.1不带头节点的操作

2.1.1 打印 

2.1.1.1 创建结点

2.1.2 尾插（需要二级指针）

注意形参的值不改变实参：（精髓部分）

2.1.3 头插

2.1.4 尾删

2.1.5 头删

2.1.6 查找

2.1.7 在pos前插入

 一级指针和二级指针的区别

2.1.8 删除pos位置 

2.1.9 在pos之后插入

2.1.20 删除pos之后的元素

注意错误写法

2.1.21 销毁 

不带头结点的完整代码 

一. 单链表的特点

单链表的结点是随机的不是逻辑上相邻即物理上相邻的。用指针指向下一个节点的地址。

1.1 解引用拓展 🤖

解引用有两种，* ->

*p的意思是：是取p所指向内存的值，取多少大小的值，取决于结构体前的数据类型，如int                         取四个字节，char取一个字节。

p->的意思是： 结构体用->,取决于->后面是什么值，如果是->val则取data域的值，->next则                       取下个结点的地址。相当于（*p）.next

二. 单链表的操作

单链表分为带头结点和不带头结点 ☆*: .｡. o(≧▽≦)o .｡.:*☆

2.1不带头节点的操作

2.1.1 打印 

打印不用二级指针的原因是：打印不用改变外部结构体指针，只用遍历打印就好了，当要改变结构体指针就要用二级指针。

void SLTPrint(SLNode* phead)
{
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}
2.1.1.1 创建结点
SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

2.1.2 尾插（需要二级指针）

void SLTPushBack(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

注意形参的值不改变实参：（精髓部分）

接下来是很多人都迷迷糊糊搞不懂的地方。

当前函数定义的可以直接修改，不是当前当前函数定义的，无论是外部函数，还是malloc出来的空间，访问时都要用指针去通过地址修改。全局变量可以直接修改。

形参不不能改变实参的，要传实参的地址才能改变形参。

想用形参pphead改变外部指针phead（实参） ，先将实参的地址&plist，传给实参pphead，这时pphead代表的是plist地址（&plist），*pphead解引用所以*pphead代表是plist，这里是要改变SNode*，所以要node**。这里是要修改结构体的指针plist，所以是需要结构体指针的地址&plist传给*pphead。

如果要改变外部定义的结构指针SLNode*，要用二级指针SLNode**。

如果要改变外部定义的结构体Node，就要一级指针Node*。

2.1.3 头插

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

2.1.4 尾删

删后n-1个不需要二级指针，直接free（）；

但是只有一个空间的时候，删掉，plist就成了没有指向空间的野指针，所以需要将plist置空，需要改变结构体指针。 

 

void SLTPopBack(SLNode** pphead)
{
	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	// 空
	assert(*pphead);

	// 1、一个节点
	// 2、一个以上节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		// 找尾
		/*SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;

		prev->next = NULL;*/

		SLNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

2.1.5 头删

void SLPopFront(SLNode** pphead) {

	assert(pphead);
	if ((*pphead)== NULL) {
		free(*pphead);
		*pphead= NULL;
	}
	else {
		/**pphead = (*pphead)->next;
		free(*pphead);*/
		SLNode* tmp = *pphead;
		*pphead = (*pphead)->next;
		free(tmp);


	}

}

2.1.6 查找

查找的作用主要是，和Insert（）配合着使用。 

void SLTFind(SLNode* phead, SLDataType x)
{
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}

	return NULL;
}

2.1.7 在pos前插入

 

//在pos之前插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLDataType x)
 {

	assert(pphead);	//plist地址不可能为NULL
	assert(!*pphead && !pos || *pphead && pos);	//	*pphead为空时pos也为NULL，
	SLNode* newnode = CreateNode(x);
	if (*pphead==pos)
	{
		SLPushFront(pphead,x);					//这里不是在测试类，没有将plist地址给pphead，*pphead表示解引用使用plist
	}
	else {
		SLNode* pre = *pphead;
		while (pre->next != pos) {
			pre = pre->next;
		}
		newnode->next = pos;
		pre->next = newnode;
	}

}

 一级指针和二级指针的区别

2.1.8 删除pos位置 

//删除pos位置的元素
void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	SLNode* pre = *pphead;
	if (*pphead==pos) {
		SLPopFront(pphead);
	}
	else 
	{
		while (pre->next != pos) {
			pre = pre->next;
		}
		pre->next = pos->next;
		free(pos);
		pos->next = NULL;
	}

}

2.1.9 在pos之后插入

//在pos的之后插入
void SLTInsertAfter(SLNode** pphead, SLNode* pos, SLDataType x)
{
	assert(pphead);
	assert(!*pphead && !pos || *pphead && pos);
	SLNode* newnode = CreateNode(x);
	if (*pphead == pos) 
	{
		SLPushFront(pphead, x);
	}
	else 
	{
		newnode->next = pos->next;
		pos->next = newnode;
	}


}

2.1.20 删除pos之后的元素

//删除指定位置的下一个位置
void SLTEraseAfter(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos->next != NULL);
	SLNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}
注意错误写法

 pos->next = pos->next->next;

 free(pos->next);

错误原因：这里pos->next已经赋值成pos->next->next。所以真正删除的其实是 pos->next->next，其次这样会导致单链表断裂，后面的结点会没有指针指向成野结点。

 

2.1.21 销毁 

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

不带头结点的完整代码 

//头文件
#pragma once
#include<stdio.h>
#include<stdlib.h>

typedef int SLDataType;
typedef struct SListNode {

	SLDataType val;
	struct SListNode* next;

}SLNode;

void SLPrint(SLNode* phead);
void SLPushBack(SLNode** pphead, SLDataType x);
void SLPopBack(SLNode** pphead);
void SLPushFront(SLNode** pphead, SLDataType x);
void SLPopFront(SLNode** pphead);
SLNode* SLTFind(SLNode* phead, SLDataType x);
void SLTInsert(SLNode** pphead, SLNode* pos, SLDataType x);
void SLTInsertAfter(SLNode** pphead, SLNode* pos, SLDataType x);
void SLTErase(SLNode** pphead, SLNode* pos);
void SLTEraseAfter(SLNode** pphead, SLNode* pos);
void STDestory(SLNode** pphead);

//SList.c文件
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include"SList.h"
#include<assert.h>
//打印
void SLPrint(SLNode* phead) {

	assert(phead);
	while (phead!= NULL) {
		printf("%d->", phead->val);
		phead = phead->next;
	}
	printf("NULL\n");
}
//创建新节点

SLNode* CreateNode(SLDataType x) {

	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	while (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;

}

//尾插
void SLPushBack(SLNode** pphead, SLDataType x) {
	SLNode* newnode = CreateNode(x);		//调用函数,实参没有数据类型
	if (*pphead == NULL) {
		*pphead = newnode;
	}
	else {
	
		SLNode* tail = *pphead;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		newnode->next = NULL;
		tail->next = newnode;
	}

}
//尾删
void SLPopBack(SLNode** pphead) {

	assert(*pphead);
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	else {
		SLNode* pre = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL) {
			pre = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		pre->next = NULL;

	}

}
//头插
void SLPushFront(SLNode** pphead, SLDataType x) {
	SLNode* newnode = CreateNode(x);
	/*if (*pphead == NULL) {
		*pphead = newnode;
	}*/    //可以不要
	newnode->next = *pphead;
	*pphead= newnode;
}
//头删
void SLPopFront(SLNode** pphead) {

	assert(*pphead);
	if ((*pphead)== NULL) {
		free(*pphead);
		*pphead= NULL;
	}
	else {
		/**pphead = (*pphead)->next;
		free(*pphead);*/
		SLNode* tmp = *pphead;
		*pphead = (*pphead)->next;
		free(tmp);


	}

}
// 查找
SLNode* SLTFind(SLNode* phead, SLDataType x)
{
	SLNode* cur = phead;		//查找不需要二级指针，所以phead为头指针
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}

	return NULL;
}
//在pos之前插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLDataType x)
 {

	assert(pphead);	//plist地址不可能为NULL
	assert(!*pphead && !pos || *pphead && pos);	//	*pphead为空时pos也为NULL，
	SLNode* newnode = CreateNode(x);
	if (*pphead==pos)
	{
		SLPushFront(pphead,x);					//这里不是在测试类，没有将plist地址给pphead，*pphead表示解引用使用plist
	}
	else {
		SLNode* pre = *pphead;
		while (pre->next != pos) {
			pre = pre->next;
		}
		newnode->next = pos;
		pre->next = newnode;
	}

}
//在pos的之后插入
void SLTInsertAfter(SLNode** pphead, SLNode* pos, SLDataType x)
{
	assert(pphead);
	assert(!*pphead && !pos || *pphead && pos);
	SLNode* newnode = CreateNode(x);
	if (*pphead == pos) 
	{
		SLPushFront(pphead, x);
	}
	else 
	{
		newnode->next = pos->next;
		pos->next = newnode;
	}


}
//删除pos位置的元素
void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	SLNode* pre = *pphead;
	if (*pphead==pos) {
		SLPopFront(pphead);
	}
	else 
	{
		while (pre->next != pos) {
			pre = pre->next;
		}
		pre->next = pos->next;
		free(pos);
		pos->next = NULL;
	}

}
//删除指定位置的下一个位置
void SLTEraseAfter(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos->next != NULL);
	SLNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}
//销毁
void STDestory(SLNode** pphead)
{
	assert(pphead);
	SLNode* cur = *pphead;
	while (cur != NULL) {
		SLNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	*pphead = NULL;
}

//Test.c 文件
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"

void Test1() {
	SLNode* splist=NULL;
	SLPushBack(&splist, 1);
	SLPushBack(&splist, 2);
	SLPushBack(&splist, 3);
	SLPushBack(&splist, 4);
	SLPrint(splist);
	SLPopBack(&splist);
	SLPopBack(&splist);
	SLPrint(splist);
	SLPushFront(&splist, 1);
	SLPushFront(&splist, 2);
	SLPushFront(&splist, 3);
	SLPushFront(&splist, 4);
	SLPrint(splist);
	SLPopFront(&splist);
	SLPopFront(&splist);
	SLPrint(splist);
	
}
void Test2() {
	SLNode* splist = NULL;
	SLPushBack(&splist, 1);
	SLPushBack(&splist, 2);
	SLPushBack(&splist, 3);
	SLPushBack(&splist, 4);
	SLPrint(splist);
	SLNode* pos = SLTFind(splist, 3);
	SLTInsert(&splist, pos, 20);
	SLPrint(splist);
	pos = SLTFind(splist, 4);
	SLTInsertAfter(&splist, pos, 30);
	SLPrint(splist);
	pos = SLTFind(splist, 2);
	SLTErase(&splist, pos);
	SLPrint(splist);
	pos = SLTFind(splist, 3);
	SLTEraseAfter(&splist, pos);
	SLPrint(splist);
	STDestory(&splist);
	SLPrint(splist);
}
int main() {
	Test2();
	return 0;

}

深中笃行
关注
  • 7
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
王道考研数据结构单链表代码（带头节点）
05-28
自己写的王道考研数据结构单链表（带头结点）例题和习题代码，所有函数运行都没问题。
考研861数据结构单链表的重要代码.docx
10-17
考研861数据结构单链表的重要代码
删除链表中的节点
m0_63442383的博客
04-22 844
237. 删除链表中的节点（leetcode） 请编写一个函数，用于 删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 。 示例 1： 输入：head = [4,5,1,9], node = 5 输出：[4,1,9] 解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9 示例 2： 输入：head...
单链表的算法之删除节点
weixin_46571142的博客
12-22 7640
单链表的算法之删除节点 1.为什么要删除节点 (1)有时候链表节点中的数据不想要了，因此要删掉这个节点。 2.删除节点的2个步骤 (1)第一步：找到要删除的节点；第二部：删除这个节点 3.如何找到待删除的节点 (1)通过遍历来查找节点。从头指针+头结点开始，顺着链表依次将各个节点拿出来，按照一定的方法比对，找到我们要删除的那个节点。 4.如何删除一个节点 (1)待删除的节点不是尾结点的情况：首先把待删除的节点的前一个节点的pNext指针指向待删除的节点的后一个节点的首地址(这样就把这个节点从链表中摘出来了)
数据结构之----单链表的增删查改以及销毁
2301_79582015的博客
04-16 608
创作人：北海有初拥（小菜鸡一枚）
单链表的节点删除,基础讲解及习题练习
hyoo_的博客
03-19 2820
单链表的删除常用两种方法： 1.删除p->next的节点 { q=p->next; p->next=q->next; free(q); } 2.删除p指向的节点（需要引入前驱节点q） { q=head; while(q->next!=p) q=q->next; q->next=p->next; free(p); } 常采用第一种删除方式，现在展示删除p->next节点的自定义函数 ..
单链表的删除
Kegi_的博客
01-26 384
如果在我们不知道第i个结点的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。q=p->next;解读这两句代码，也就是说把p的后继结点改成p的后继的后继结点。设存储元素ai的结点为q，要实现将结点q删除单链表的操作，其实就是将它的前继结点的指针绕过，指向它的后继结点即可。顺序存储结构意味着，每一次插入都需要移动n-i个结点，每次都是O(n)。
王道考研数据结构单链表代码（不带头节点）
05-28
自己写的王道考研数据结构单链表（不带头结点）例题和习题代码，所有函数运行都没问题。
王道考研——数据结构PPT.zip
08-21
王道考研——数据结构PPT.zip
【考研必备】数据结构-思维导图.pdf
05-15
1、在408真题中的数据结构部分的题目可以看出：选择题大多考察相应结构/算法的中间过程，能从计算机的角度出发去思考计算机处理这个问题处理的整个过程是什么样的，而不要从个人主观上出发去看此结构/算法；...
数据结构：删除单链表中p节点，时间复杂度O(1)
WangGarrison的博客
07-27 2956
题目背景 在plist中删除p节点，时间复杂度要求O(1) 算法 因为时间复杂度为O(1)，所以常规思路遍历链表是不行的。删除节点，其实是把该节点数据域清除，已知了p节点，那么可以知道它的next节点，所以可以把p节点的下一个节点的数据域赋值给p节点数据域，再让p节点的next指向p->next->next，就实现了p节点数据域的清除，也就间接删除了p节点。 如果p是最后一个节点，则只好遍历链表，复杂度O(n) 只有p是最后一个节点时间复杂度才是O(n),平均时间复杂度(O(1)*(n-1) +
2.3.2 单链表的删除结点操作
qq_62642833的博客
04-12 1691
基本逻辑：代码理解：1.将q.data赋值给e，定义的&e表示值会返回给系统（因为后面会删除）2.将q.next指向NULL3.调用free函数把a4结点给释放掉4.时间复杂度。
单链表之删除节点
weixin_54989626的博客
08-14 7698
1.删除节点的步骤 （1）找到要删除的这个节点：通过遍历来查找节点，从头指针+头节点开始，顺着链表依次将各个节点拿出来，按照一定的方法比对，找到我们要删除的那个节点。 （2）删除这个节点 （2.1）如果不是尾节点：首先把待删除节点的前一个节点的pNext指向待删除节点的后一个节点的首地址，然后再将摘出来这个节点free掉。 （2.2）如果这个节点是尾节点，首先把待删除这个节点的前一个节点的pNext指针指向NULL，然后再将摘出来这个节点free掉。 #include <stdio.h> #in
【数据结构】单链表的实现
学了就忘是正常现象
08-05 882
现代链条焊接技术解析
单链表查找与删除
qq_65761686的博客
07-27 380
在上述代码中，首先检查头节点是否就是待删除节点，如果是则将头节点的下一个节点作为新的头节点返回。否则，使用一个循环找到待删除节点的前一个节点，然后将前一个节点的指针指向待删除节点的下一个节点，并跳出循环。要查找单链表中的一个节点，需要从链表的头节点开始，沿着指针依次遍历每个节点，直到找到目标节点或者到达链表的末尾（即指针为null）为止。要删除单链表的中间或尾节点，需要先找到待删除节点的前一个节点，然后将其指针指向待删除节点的下一个节点。要删除单链表的头节点，只需将头节点的下一个节点设为新的头节点。
删除链表中给定节点
m0_54657729的博客
03-21 352
删除链表中给定节点
在单链表中删除指定值的节点
孤舟钓客
11-21 1823
在单链表中删除指定值的节点 题目 给定一个单链表和一个数val，删除链表中所有值为val的节点。例如： 1->2->3->4，删除3，结果为： 1->2->4 思路1: 用栈 def remove_node_with_val1(head, val): stack = [] p = head while p: if p.val !...
【C语言 | PTA】单链表结点删除
等风来
06-15 6195
函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。函数deletem将单链表L中所有存储了m的结点删除。返回指向结果链表头结点的指针。
计算机考研数据结构哪一本书
最新发布
05-14
计算机考研数据结构相关的书籍有很多，以下是一些比较经典的书籍： 1.《数据结构(C++语言版)》严蔚敏、吴伟民著：该书详细介绍了数据结构的基本概念、常见数据结构的实现及其应用，并提供了大量的习题和编程实践，适合初学者学习。 2.《算法导论(原书第3版)》Thomas H. Cormen等著：该书不仅包含了数据结构的基础知识，还详细介绍了算法设计和分析的方法，对于提高算法能力和编程水平非常有帮助。 3.《数据结构与算法分析——C语言描述(第2版)》Mark Allen Weiss著：该书采用C语言描述数据结构及算法分析，内容丰富，涵盖了基本数据结构、高级数据结构以及算法设计和分析等方面。 4.《数据结构与算法分析——Java语言描述(第3版)》Mark Allen Weiss著：该书与上一本类似，采用Java语言描述数据结构和算法，适合Java程序员学习。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值