(6)数据结构与算法-无空头链表的节点交换

最新推荐文章于 2024-11-05 21:58:11 发布
最新推荐文章于 2024-11-05 21:58:11 发布
阅读量216 收藏 1
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_shmily_/article/details/118069554
版权

链表 算法 数据结构

无空头链表的节点交换

交换数据

根据数据查找交换

注意：若有几个相同的数据，是交换第一个数据

利用中间变量交换

数据的交换，对于指针指向是不变的，所以传一级指针就可
1.找到数据一的节点地址，找到数据二的节点地址，判断两个是否为空

2.不为空则交换，结构体允许直接交换
或者节点直接互相赋值
字符串必须调用strcpy或者循环赋值
3.为NULL，无法交换

void SwopiData(struct Chain *pHead, int iData1, int iData2)
{
//合法性检测
	if (NULL == pHead->pNext || NULL == pHead)
		return;
//找到两个节点
	struct Chain *pTemp1 = FindiData(pHead, iData1);
	struct Chain *pTemp2 = FindiData(pHead, iData2);
//交换
	if (pTemp1 != NULL && pTemp2 != NULL)
	{
		int pTemp = pTemp1->iData;
		pTemp1->iData = pTemp2->iData;
		pTemp2->iData = pTemp;
	}

利用mencpy内存拷贝交换

	struct chain pT = *pTemp1;
	memcpy(pTemp1,pTemp2,4);
	memcpy(pTemp2,&pT,4);

纵使要交换的特别多，只要这两行就够了

根据下标查找交换

和根据数据查有异曲同工之妙

void SwopiIndex(struct Chain *pHead, int iIndex1, int iIndex2){
	if (NULL == pHead->pNext || NULL == pHead)
		return;
	struct Chain *pTemp1 = FindIndex(pHead, iIndex1);
	struct Chain *pTemp2 = FindIndex(pHead, iIndex2);
	if (pTemp1 != NULL && pTemp2 != NULL){
		int pTemp = pTemp1->iData;
		pTemp1->iData = pTemp2->iData;
		pTemp2->iData = pTemp;
	}
}

交换节点指向

与交换数据不同，交换数据节点的位置不变，只是变得是数据，而交换节点是指针的指向变了，节点中的数据是不变的，这有可能改变头尾指针的指向，所以要传二级指针。
1）参数合法性检测
交换两个节点，所以节点要多于一个节点–下标不能相等

if (NULL == *pHead || (*pHead)->pNext == NULL || iIndex1 == iIndex2 || iIndex1 < 0 || iIndex2 < 0)
		return;

2）确定两下标的大小关系，这样就固定是某一个会装头，另一个一定不会装头，就不用再单独判断了

//确定大小关系
	int Max = iIndex1;
	int Min = iIndex2;
	if (iIndex1<iIndex2){
		Max = iIndex2;
		Min = iIndex1;
	}

3）根据下标找节点

//根据下标找节点
	struct Chain *pMin = FindIndex(*pHead, Min);
	struct Chain *pMax = FindIndex(*pHead, Max);

4）交换节点
上面已经确定了大小关系，所以这里头指针一定是装在Min中的，就不用再判断另一个了，也是提高程序的逻辑。
分为4种情况：交换头与尾；交换头与中间；交换尾与中间；交换中间两个节点。

交换头与尾节点

两种情况：链表有两个节点、链表有3个以上节点
a)判断是否找到

	//判断是否找到
	if (NULL == Min || NULL == Max)
		return;

b)头尾交换
交换条件是找到的节点，一个是头，一个是尾
条件内又有两种情况：一种是只有两个节点，一种是有多个节点

//头尾交换
	if (Max == *pHead && Min == *pTail){
		//两个节点
		if ((*pHead)->pNext == *pTail){}
		else{}//多个节点
	}

c)先连后断
先将尾连到头

			(*pTail)->pNext = *pHead;

再将头断开

			(*pHead)->pNext = NULL;

d)头尾指针的交换，让头指针指向新头，尾指针指向新尾。

//交换指针指向 让头指针变为指向新头
			*pHead = *pTail;
			*pTail = (*pHead)->pNext;

e)处理多个节点的情况
头和尾中间有多个节点，尾如果直接指向头节点，那么尾部的节点就会丢失，我们需要先找到尾节点的前一节点，将尾指向第二个节点位置即(*pHead)->pNext，然后将头部接到尾巴上,再断开头部的pNext即可
找尾的前一个节点

//找尾的前一节点
			struct Chain*pTemp = FindIndex(*pHead,Max-1); 
			Max一定装的是尾节点

尾变头 将尾节点移前面去

//尾变头
			(*pTail)->pNext = (*pHead)->pNext;

头变尾 将头部移后面去

//头变尾
			pTemp->pNext = *pHead;

头下一个为空

//头下一个为空
			(*pHead)->pNext = NULL;

交换指针指向

//交换指向
			*pHead = *pTail;
			*pTail = pTemp->pNext;

总代码如下：

void SwopDir(struct Chain **pHead,struct Chain**pTail, int iIndex1,int iIndex2)
{
	if (NULL == *pHead || (*pHead)->pNext == NULL || iIndex1 == iIndex2 || iIndex1 < 0 || iIndex2 < 0)
		return;
	//确定大小关系
	int Min = iIndex1;
	int Max = iIndex2;
	if (iIndex1>iIndex2)
	{
		Min = iIndex2;
		Max = iIndex2;
	}
	//根据下标找节点
	struct Chain *pMin = FindIndex(*pHead, Min);
	struct Chain *pMax = FindIndex(*pHead, Max);
	//判断是否找到
	if (NULL == pMin || NULL == pMax)
		return;
	//头尾交换
	if (pMin == *pHead && pMax == *pTail)
	{ 
		//两个节点
		if ((*pHead)->pNext == *pTail)
		{
			//先连后断  头指针和尾指针交换
			(*pTail)->pNext = *pHead;
			(*pHead)->pNext = NULL;
			//交换指针指向 让头指针变为指向新头
			*pHead = *pTail;
			*pTail = (*pHead)->pNext;
		}
		else   //多个节点
		{
			//找尾的前一节点
			struct Chain*pTemp = FindIndex(*pHead,Max-1); //Max一定装的是尾节点
			//尾变头
			(*pTail)->pNext = (*pHead)->pNext;
			//头变尾
			pTemp->pNext = *pHead;
			//头下一个为空
			(*pHead)->pNext = NULL;
			//交换指向
			*pHead = *pTail;
			*pTail = pTemp->pNext;
		}
	}
}

交换头与中间节点

也是两种情况：与头节点相邻，与头节点不相邻
相邻
1）条件判断，pMin->pNext == pMax
2)pMin即头节点指向相邻节点的下一节点

			pMin->pNext = pMax->pNext;

3)相邻节点指向头节点，此时相邻节点就变成了头节点

			pMax->pNext = pMin;
			//头指向pMax
			*pHead = pMax;

不相邻
1）找pMax的前一节点

struct Chain *pTemp = FindIndex(*pHead,Max-1);

2）记录头的下一节点，一会要将pMax的节点指向它

struct Chain *HeadNext = (*pHead)->pNext;

3）头节点移到后面

pMin->pNext = pMax->pNext;
pTemp->pNext = Min;

4）pMax移到头

pMax->pNext = HeadNext;

5）改变新的头

*pHead = pMax;

交换尾与中间

两种情况：与尾节点相邻，不相邻。
具体看代码：不相邻是唯一特殊的，要记录两个的前节点，才能找到。

//交换尾和中间节点
	else if (pMin != *pHead && pMax == *pTail)
	{
		//相邻
		if (pMin->pNext == pMax)
		{
			//找到pMin的前一个节点
			struct Chain *pTemp = FindIndex(*pHead,Min-1);
			//尾移到中间
			pTemp->pNext = pMax;
			//中间移到尾
			pMax->pNext = pMin;
			//下一个赋值为NULL
			pMin->pNext = NULL;
			//尾指针重新变成尾
			*pTail = pMin;
		}
		//不相邻
		else
		{
			//记录pMax和pMin前一个节点
			struct Chain *pTemp1 = FindIndex(*pHead, Min - 1);
			struct Chain *pTemp2 = FindIndex(*pHead, Max - 1);
			//pMin前一个接pMax
			pTemp1->pNext = pMax;
			//pMax指向pMin的下一个节点
			pMax->pNext = pMin->pNext;
			//断开pMin,将pTemp1指向pMin
			pTemp2->pNext = pMin;
			//现在pMin在尾，赋空
			pMin->pNext = NULL;
			//将尾指针指向尾
			*pTail = pMin;
		}
	}

交换中间与中间

也是分相邻与不相邻进行讨论
具体看代码，每一步都有注释

	//交换两个中间节点
	else if (pMin != *pHead && pMax != *pTail)
	{
		//相邻
		if (pMin->pNext == pMax)
		{
			//记录pMin前一个节点
			struct Chain *pTemp = FindIndex(*pHead,Min-1);
			//pMin移到后面
			pMin->pNext = pMax->pNext;
			//pMax指向pMin
			pMax->pNext = pMin;
			//pMin前一节点指向pMax
			pTemp->pNext = pMax;

		}
		//不相邻
		else
		{
			//记录两个节点的前节点
			struct Chain *pTemp1 = FindIndex(*pHead, Min - 1);
			struct Chain *pTemp2 = FindIndex(*pHead, Max - 1);
			//将pMin移到pMax位置
			pMin->pNext = pMax->pNext;
			pTemp2->pNext = pMin;
			//将pMax移到pMin位置
			pMax->pNext = pTemp2;
			pTemp1->pNext = pMax;
		}

翻转链表

翻转链表，也就是链表的顺序完全倒过来了

比如：一链表为1、2、3、4、5
反转链表：5、4、3、2、1

原链表直接操作

数据翻转

思路

计算链表节点数，然后前后成对交换数据

注意

数据翻转，只是数据变动，节点指向不变

节点指向不改变，传一级指针就可以；函数体中，节点数要两个或两个以上，获取节点数
循环交换：相当于有两个下标，一个从小往大，一个从大到小，小<大即可，循环内交换节点内容，调用节点交换函数

void ReverseData(struct Chain *pHead)
{
	//合法性检测
	if (NULL == pHead || NULL == pHead->pNext)
		return;
	//记录节点数量
	int iCount = GetCount(pHead);
	//循环交换  两边交换同时循环
	//下标最大为iCount-1
	for (int i = 0, j = iCount - 1; i < j; i++, j--) 
		SwopIndex(pHead, i, j);
}

节点翻转

注意：数据不变，节点指向改变 要传二级指针
和数据翻转大体相似，只是要循环调用的函数不同

void ReverseIndex(struct Chain**pHead,struct Chain**pTail)
{
	if (NULL == *pHead || NULL == (*pHead)->pNext)
		return;
	int iCount = GetCount(*pHead);
	//循环交换
	for (int i = 0, j = iCount - 1; i < j; i++, j--)
		SwopDir(pHead,pTail,i,j);  
		
}

空间辅助

既是对当先链表进行遍历，通过头添加的方式加进另外一个链表中，然后头指针和尾指针都指向新链表中的头和尾，释放之前的链表
头和尾要指向新的节点，改变方向，所以要传二级指针

void BySpace(struct Chain**pHead, struct Chain **pTail)
{
	//合法性检测
	if (NULL == *pHead || NULL == (*pHead)->pNext)
		return;
	//中间变量  二级指针 头指针会变
	struct Chain *pTemp = *pHead;
	//定义新头、尾
	struct Chain *pNewHead = NULL,
				 *pNewTail = NULL;
	//遍历链表
	while (NULL != pTemp)
	{	//在头添加 代码段在前面
		AddHead(&pNewHead,&pNewTail,pTemp->iData );
		pTemp = pTemp->pNext;
	}
	//释放原链表  代码段在前面
	FreeChain(pHead,pTail);
	//原头尾指针指向新头尾
	*pHead = pNewHead;
	*pTail = pNewTail;
}
沐鑫本鑫
关注
专栏目录
【实战】ACM 选手图解 LeetCode 交换链表
用有趣有味的方式，学习有价值的编程知识。
02-13 405
图解 LeetCode 24：交换链表。
链表的冒泡排序-没有头结点，交换链表节点
dianjige2532的博客
08-28 441
问题描述： 对一个没有头结点的链表进行冒泡排序，如果出现逆序交换链表的节点，而不是交换链表的值。 #include<iostream> #include<vector> #include<map> #include<string> using namespace std; struct ListNode { i...
算法-两两交换链表节点(不能使用值交换方式)
qq_26105397的博客
07-30 170
链表算法.
LeetCode 24 两两交换链表中的节点
猫头夜鹰的小屋
09-09 107
LeetCode 24 两两交换链表中的节点
单链表（不带头结点）各种操作
韩豆豆小姐的博客
07-04 3068
主函数中根据需求直接调用就可。 单链表结构定义 struct ListNode { int val; ListNode *next; ListNode() : val(0), next(NULL) {} ListNode(int x) : val(x), next(NULL) {} ListNode(int x, ListNode *next) : val(x), next(next) {} }; 各个子函数功能及说明 ListNode *cr
(4)数据结构与算法-无空头链表的添加
A_shmily_的博客
06-16 310
单向链表基本概括二级目录三级目录 基本概括 链表的常用结构主要成分有空头有链表与无空头链表 二级目录 三级目录
(5)数据结构与算法-无空头链表的删、改、查
A_shmily_的博客
06-20 244
无空头链表的删、改、查
(7)数据结构与算法-有空头链表的创建与添加
A_shmily_的博客
08-11 597
有空头链表介绍特点链表的创建空头的创建节点计数器的建立链表的添加尾添加释放链表 介绍 特点 1）第一个节点不装数据作为链表头（永远不变），从第二个节点开始有数据 2）不使用尾指针，涉及尾部，循环寻找；目的是与之前写的不一样，更有意思！ 3）操作原理和操作逻辑和无空头链表基本一样，多了空头，代码部分也会稍有不同 4）与无空头链表的区别：有空头一些操作会比无空头的简单一些 链表的创建 空头的创建 //单独创建空头链表节点 struct Chain Head = {0，NULL}; //或者 struct
数据结构学习笔记-单链表
02-16
在VS2022环境下编写单链表代码时，首先需要定义一个结构体来表示链表节点。这个结构体通常包含一个数据成员和一个指向下一个节点的指针成员。例如： ```cpp struct ListNode { int data; ListNode* next; }; ``` ...
24. 两两交换链表中的节点（中等 链表 递归）
weixin_43942435的博客
01-06 689
24. 两两交换链表中的节点 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。 示例 1： 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1] 提示： 链表中节点的数目在范围 [0, 100] 内 0 <= Node.val <= 100 来源：力扣（LeetCode） 链接：https://le
c代码-重新测试链表
07-14
在IT行业中，链表是一种基础且重要的数据结构，它在许多算法和程序设计中都扮演着关键角色。本文将深入探讨“C代码-重新测试链表”这一主题，结合提供的文件`main.c`和`README.txt`，我们将讨论C语言中的链表实现，...
数据结构与算法 第二章线性表笔记
weixin_46521624的博客
09-02 489
数据结构 第二章线性表笔记
【 C# 】（一） --------- 泛型带头节点的单链表，双向链表实现
爱喝柠檬的二哈的博客
09-24 652
在编程领域，数据结构与算法向来都是提升编程能力的重点。而一般常见的数据结构是链表，栈，队列，树等。事实上C#也已经封装好了这些数据结构，在头文件 System.Collections.Generic 中，直接创建并调用其成员方法就行。不过我们学习当然要知其然，亦知其所以然。 本文实现的是链表中的单链表和双向链表，并且实现了一些基本方法 一. 定义一个链表接口 MyList 接口里声明了...
算法基础-链表
August的专栏
11-05 238
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 349
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 332
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2013
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二叉树(一)
m0_74340589的博客
11-05 450
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
JavaCV 图像边缘检测 之 Sobel算子 算法
欢迎拜读我的作品，喜欢的领域请给我留言
11-04 1557
JavaCV 是一个基于 OpenCV 和 FFmpeg 的 Java 计算机视觉库。它提供了对各种计算机视觉算法和图像处理功能的访问，包括图像读取、处理、显示，以及视频处理等。JavaCV 封装了底层的 C/C++ 库，使得在 Java 中进行计算机视觉开发更加方便快捷。本文详细介绍了JavaCV中的Sobel 算子在边缘检测中的应用。从Sobel 算子的原理出发，阐述了一阶导数与边缘检测的关系，以及Sobel 算子的卷积核和边缘检测过程。接着介绍了JavaCV的简介和Maven。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沐鑫本鑫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值