Lesson2无头单向非循环链表(中)

已于 2023-03-08 18:28:41 修改
阅读量312 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2023-01-18 00:31:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiguazkb123/article/details/128721564
版权

1.链表

1.1链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

 1.2链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。 

2.链表的实现

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
//写入访问权限冲突 解决方法:#include <stdlib.h>

//无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;//数据域--存储数据
	struct SListNode* next;//指针域--存放下一个节点的地址
}SLTNode;

// 动态申请一个节点
SLTNode* BuyListNode(SLTDateType x);

// 单链表打印
void SListPrint(SLTNode* phead);

// 单链表尾插
void SListPushBack(SLTNode** pphead, SLTDateType x);

// 单链表的头插
void SListPushFront(SLTNode** pphead, SLTDateType x);

// 单链表的尾删
void SListPopBack(SLTNode** pphead);

// 单链表头删
void SListPopFront(SLTNode** pphead);

// 单链表查找
SLTNode* SListFind(SLTNode* phead, SLTDateType x);

//pos位置之前插入
void SListInsert(SLTNode**pphead, SLTNode* pos, SLTDateType x);

// 在pos的后面插入，这个更适合，也更简单
void SListInsertAfter(SLTNode* pos, SLTDateType x);

//单链表在pos位置上删除
void SListErase(SLTNode *pphead, SLTNode* pos);

//单链表在pos后面删除
void SListEraseAfter(SLTNode* pos)

//单链表的释放
void SListDestory(SLTNode** pphead);

传二级指针是为了改变头指针的指向 

2.1动态申请一个节点

SLTNode* BuyListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

2.2单链表打印

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

2.3单链表尾插

void SListPushBack(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//判断是否为空结点
	if (*pphead == NULL)
	{
		*pphead = newnode;//==*plist=newnode
	}
	else
	{
		//找到尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

2.4单链表的头插

void SListPushFront(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//不用判空
	newnode->next = *pphead;
	*pphead = newnode;

}

2.5单链表的尾删

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	//判断是否空链表--非法访问
	//a.温柔地方式
	if (*pphead == NULL)
	{
		return;
	}
	//b.暴力地方式
	///assert(*pphead != NULL);

	//1.一个节点
	//2.两个以上节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);//释放pphead指向的
		*pphead = NULL;
	}
	else
	{
	//方法一:
	SLTNode* tail = *pphead;
	SLTNode* prev = NULL;
	while (tail->next/*tail->next != NULL*/)
	{
		prev = tail;
		tail = tail->next;
	}
	free(tail);
	tail = NULL;
	prev->next = NULL;//一个节点非法访问

	//方法二:
	//SLTNode* tail = *pphead;
	//while (tail->next->next)//一个节点非法访问
	//{
	//	tail = tail->next;
	//}
	//free(tail->next);
	//tail->next = NULL;

	}
}

2.6单链表头删

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	//判断是否空链表--非法访问
	//a.温柔地方式
	if (*pphead == NULL)
	{
		return;
	}
	//b.暴力地方式
	///assert(*pphead != NULL);

	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;

}

 2.7单链表查找

SLTNode* SListFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

2.8pos位置之前插入

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//找到pos的前一个位置
		SLTNode* posPrev = *pphead;//pos为第一个节点时,posPrev找不到
		while (posPrev->next != pos)
		{
            posPrev=posPrev->next;
		}
			posPrev->next = newnode;
			newnode->next = pos;
	}
}

2.9在pos的后面插入，这个更适合，也更简单

void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

2.10单链表在pos位置上删除

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		*pphead = pos->next;
		free(pos);
		pos = NULL;
		//SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while(prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;//置空与不置空都可以
		//pos不置空也无所谓，毕竟在函数中是形参，形参的改变不会影响实参，处于好习惯，还是置空比较好
	}
}

2.11 单链表在pos后面删除

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

2.12单链表的释放

void SListDestory(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

3.代码

SList.h

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
//写入访问权限冲突 解决方法:#include <stdlib.h>

//无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SLTNode;

// 动态申请一个节点
SLTNode* BuyListNode(SLTDateType x);

// 单链表打印
void SListPrint(SLTNode* phead);

// 单链表尾插
void SListPushBack(SLTNode** pphead, SLTDateType x);

// 单链表的头插
void SListPushFront(SLTNode** pphead, SLTDateType x);

// 单链表的尾删
void SListPopBack(SLTNode** pphead);

// 单链表头删
void SListPopFront(SLTNode** pphead);

// 单链表查找
SLTNode* SListFind(SLTNode* phead, SLTDateType x);

//pos位置之前插入
void SListInsert(SLTNode**pphead, SLTNode* pos, SLTDateType x);

// 在pos的后面插入，这个更适合，也更简单
void SListInsertAfter(SLTNode* pos, SLTDateType x);

//单链表在pos位置上删除
void SListErase(SLTNode *ppphead, SLTNode* pos);

//单链表在pos后面删除
void SListEraseAfter(SLTNode* pos)

//单链表的释放
void SListDestory(SLTNode** pphead);

 SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuyListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail]\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SListPushBack(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//判断是否为空结点
	if (*pphead == NULL)
	{
		*pphead = newnode;//==*plist=newnode
	}
	else
	{
		//找到尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	//判断是否空链表--非法访问
	//a.温柔地方式
	if (*pphead == NULL)
	{
		return;
	}
	//b.暴力地方式
	///assert(*pphead != NULL);

	//1.一个节点
	//2.两个以上节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);//释放pphead指向的
		*pphead = NULL;
	}
	else
	{
	//方法一:
	SLTNode* tail = *pphead;
	SLTNode* prev = NULL;
	while (tail->next/*tail->next != NULL*/)
	{
		prev = tail;
		tail = tail->next;
	}
	free(tail);
	tail = NULL;
	prev->next = NULL;//一个节点非法访问

	//方法二:
	//SLTNode* tail = *pphead;
	//while (tail->next->next)//一个节点非法访问
	//{
	//	tail = tail->next;
	//}
	//free(tail->next);
	//tail->next = NULL;

	}
}

void SListPushFront(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//不用判空
	newnode->next = *pphead;
	*pphead = newnode;

}

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	//判断是否空链表--非法访问
	//a.温柔地方式
	if (*pphead == NULL)
	{
		return;
	}
	//b.暴力地方式
	///assert(*pphead != NULL);

	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;

}

SLTNode* SListFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//找到pos的前一个位置
		SLTNode* posPrev = *pphead;//pos为第一个节点时,posPrev找不到
		while (posPrev->next != pos)
		{
			posPrev->next = newnode;
			newnode->next = pos;
		}
	}
}
// 在pos的后面插入，这个更适合，也更简单
void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		*pphead = pos->next;
		free(pos);
		pos = NULL;
		//SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while(prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;//置空与不置空都可以
		//pos不置空也无所谓，毕竟在函数中是形参，形参的改变不会影响实参，处于好习惯，还是置空比较好
	}
}

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

void SListDestory(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

void test()
{
	SLTNode* plist = NULL;
	//*plist指向的是NULL
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 1);
	SListPrint(plist);

	SListPushFront(&plist, 2);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 2);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPopBack(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPrint(plist);

	SLTNode* pos = SListFind(plist, 2);
	int i = 1;
	while (pos)
	{
		printf("第%d个pos节点:%->%d\n", i++, pos, pos->data);
		pos = SListFind(pos->next, 2);
	}
	//修改值 2-20
	pos = SListFind(plist, 2);
	if (pos)
	{
		pos->data = 20;
	}
	SListPrint(plist);
	pos = SListFind(plist, 20);
	if (pos)
	{
		pos->data = 30;
	}
	SListPrint(plist);
	
	pos = SListFind(plist, 3);
	if (pos)
	{
		SListInsert(&plist, pos, 30);
	}
	SListPrint(plist);

	pos = SListFind(plist, 30);
	if (pos)
	{
		SListInsert(&plist, pos, 300);
	}
	SListPrint(plist);

	pos = SListFind(plist, 300);
	if (pos)
	{
		SListInsertAfter(pos, 3000);
	}
	SListPrint(plist);
	pos = SListFind(plist, 3000);
	if (pos)
	{
		SListErase(&plist, pos);
	}
	SListPrint(plist);

	pos = SListFind(plist, 300);
	if (pos)
	{
		SListEraseAfter(pos);
	}
	SListPrint(plist);
	SListDestory(&plist);

}	
int main()

{
	test();
	return 0;
}

xiguazkb123
关注
专栏目录
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
单向循环链表-约瑟夫问题
07-21
单向循环链表-约瑟夫问题
单向循环链表
01-20
从我画的循环链表图中，你应该可以看出来，它像一个环一样首尾相连，所以叫作“循环”链表。 操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item)...
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 335
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
Python 数据结构和算法面试题，使用 Jupyter Notebook 编写
hallo128的博客
10-16 423
【代码】Python 数据结构和算法面试题，使用 Jupyter Notebook 编写。
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 716
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
数据结构(8.1)——排序的基本概念
m0_65240792的博客
10-16 143
排序的定义 排序算法的评价指标 排序算法的分类 总结：
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 506
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构编程实践20讲(Python版)—09B树
AnFany
10-12 1136
数据结构编程实践20讲(Python版)—09B树
【AcWing】算法基础课-数据结构
2301_80277275的博客
10-16 639
AcWing算法基础课---数据结构笔记
数据结构常考基础代码题-数组倒置
qq_52291558的博客
10-16 299
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
嵌入式数据结构中树与查找方法实现
嵌入式技术开发
10-13 156
Tree）是nn≥0）个节点的有限集合T，它满足两个条件有且仅有一个特定的称为根Root的节点其余的节点可以分为mm≥0）个互不相交的有限集合T1T2……Tm，其中每一个集合又是一棵树，并称为其根的子树（Subtree一个节点的子树的个数称为该节点的度数一棵树的度数是指该树中节点的最大度数。度数为零的节点称为树叶或终端节点，度数不为零的节点称为分支节点，除根节点外的分支节点称为内部节点。一个节点的子树之根节点称为该节点的子节点。
数据结构 —— 树和二叉树简介
最新发布
知其然 知其所以然
10-17 643
笔者我之前讲解的数据结构都是线性的数据结构，比如：顺序表、链表、栈、队列。线性结构中存储的元素在逻辑上像是被一条线串起来的一样。现在我将介绍一种非线性的数据结构 —— 二叉树，但是介绍二叉树之前需要介绍一下树，因为二叉树是树的一种特殊情况。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。之所以把它叫做树，是因为这种数据结构看起来像一棵倒过来的树，根朝上，叶朝下，如下图所示。从上往下的第一个结点叫做根结点。
数据结构：用栈实现队列（OJ232）
2303_81073778的博客
10-14 194
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（
【数据结构】时间、空间复杂度详解
weixin_64178283的博客
10-16 722
时间复杂度和空间复杂度是评估程序性能的重要指标。时间复杂度关注程序运行时间，空间复杂度关注程序内存消耗。选择合适的算法，可以有效降低时间复杂度和空间复杂度，提高程序效率。希望这篇文章能够帮助你更好地理解时间复杂度和空间复杂度，让你在编写代码时更加得心应手！
数据结构-八大排序之归并排序
m0_75163045的博客
10-16 245
归并排序（Merge sort）是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
入门篇-2 为什么需要学习数据结构
Oo_Amy_oO的博客
10-09 391
选择合适的数据结构可以减少算法的时间复杂度，比如使用哈希表（Hash Table）可以快速检索数据，其平均时间复杂度为O(1)，而使用列表（List）进行检索的时间复杂度为O(n)。无论你是初学者还是经验丰富的开发者，不断学习和实践数据结构，都将使你在编程艺术的道路上走得更远。例如，使用位图（Bit Map）可以高效地表示大量布尔值数据，只需少量的内存空间。良好的数据结构可以提高代码的逻辑清晰度，使得代码更易于阅读和维护。许多算法，如排序、搜索、图算法等，都需要依赖特定的数据结构来实现。
[数据结构]栈的实现与应用
2301_79450966的博客
10-13 907
栈，作为一种基础且重要的数据结构，在计算机科学领域中有着广泛的应用。它不仅为函数调用提供了必要的支持，还在算法设计和问题解决中发挥着关键作用。本文将对栈的基本概念、实现方式以及函数栈帧进行详细的介绍和分析。
无头结点的循环链表如何判断完成遍历
05-22
因此，对于无头结点的循环链表，我们需要记录一个起始节点，以便在遍历时判断是否已经回到了起始节点。 具体来说，可以使用一个指针指向起始节点，然后依次访问每个节点，直到回到起始节点为止。代码实现如下： ``...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值