c语言实现单链表反转的四种方法

最新推荐文章于 2024-04-25 12:18:13 发布
最新推荐文章于 2024-04-25 12:18:13 发布
阅读量1.3w 收藏 136
点赞数 22
文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49635198/article/details/119942584
版权

链表反转即假设有一链表1->2->3，反转后为3->2->1

以下的方法是没有头节点只有首元节点的情况

方法一：迭代法
如图所示，创建三个指针。小方块从左到右的值分别为1、2、3，假设
是以1->2->3的方向，那么，如果想实现链表反转，可以让中间的mid指针
从原来指向end变为指向pre，然后三个指针整体向右移动，mid再指向pre，直到end指向了NULL为止。最后让头指针指向mid即可，此时方向变为3->2->1
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

代码如下：

#include<Stdio.h>
#include<Stdlib.h>
typedef struct Node{
	int elem;
	struct Node *next;
}node;
node *initNode(){
	node *end=(node *)malloc(sizeof(node));//尾指针 
	node *p=(node *)malloc(sizeof(node));//首元节点 
	p->elem=1;
	p->next=NULL;
	end=p;
	for(int i=2;i<=3;i++){
		node *newnode=(node *)malloc(sizeof(node));
		newnode->elem=i;
		newnode->next=NULL;
		//尾插法 
		end->next=newnode;
		end=newnode;
	}
	return p;
}
void show(node *p){
	node *temp=p;
	while(temp){
		printf("%d",temp->elem);
		temp=temp->next;
	}
	printf("\n");
}
node *iteration(node *p){
	if(p==NULL||p->next==NULL){
		return p;
	}else{
		node *pre=NULL;
		node *mid=p;
		node *end=p->next;
		while(true){
			mid->next=pre;
			if(end==NULL){
				break;
			}
			//整体右移 
			pre=mid;
			mid=end;
			end=end->next;
		}
		p=mid;//原来的头指针指向mid（因为此时mid为首元节点）
		return p; 
	}
}
int main(void){
	node *p=initNode();
	show(p);
	p=iteration(p);
	show(p);
	return 0;
}

方法二：递归法
该方法是通过递归，使得指针指向最后一个结点，然后从后往前改变指针的指向，从而实现反转。
有几点需要注意的：
1.需要建立一个头指针，返回该头指针。
2.需要建立一个从后往前递归的指针，从而不断地改变指针指向，即
head->next->next=head;
3.最重要的一点！！！
必须把原来结点的指针域置空，即head->next=NULL;不然，请看第二张图：
由于我们马上要写的函数当head指针指向1的时候，便结束循环，如果我们只写head->next->next=head;前面的2和3的指针域与确实分别指向1和2；
但是1的指针域指向的是2，当我们遍历的时候，由于循环结束的条件是：

while（temp）{
temp=temp->next;
}

当temp指针指向1的时候，temp->next指向2，即temp此时指向2，然后while循环判断不为空，从而执行temp=temp->next，又指向了1。1和2之间就形成了一个循环链表，永远不会结束循环，你会在屏幕上看到2121212121无限循环…，所以必须把原来的指针域置空！！！！
在这里插入图片描述
在这里插入图片描述

代码如下：

#include<stdio.h>
#include<stdlib.h>
typedef struct Node{
	int elem;
	struct Node *next;
}node;
node *initNode(){
	node *end=NULL;
	node *p=(node *)malloc(sizeof(node));
	p->next=NULL;
	p->elem=1;
	end=p;
	for(int i=2;i<3;i++){
		node *newnode=(node *)malloc(sizeof(node));
		newnode->next=NULL;
		newnode->elem=i;
		end->next=newnode;
		end=newnode;
	}
	return p;
}
void show(node *p){
	node *temp=p;
	while(temp){
		printf("%d ",temp->elem);
		temp=temp->next;
	}
	printf("\n");
}
node *recursion(node *p){
	if(p==NULL||p->next==NULL){
		return p;
	}else{
		node *newnode = recursion(p->next);
		p->next->next=p;
		p->next=NULL;
		return newnode;
	}
}
int main(void){
	node *p=initNode();
	show(p);
	p=recursion(p);
	show(p);
	return 0;
}

有一点需要提一下：
node *newnode = recursion(p->next);
…

return newnode;
返回值是newnode，这个值不变，一直指向末尾（即反转后链表的头指针）
而每次返回p都会左移，直到移动到原链表第一个结点为止。

方法三：新建链表
该方法是新建一个链表，然后循环要反转的链表中的每个元素，通过头插法（因为头插法会改变数据原来的顺序，正好适合反转）插入到新链表中的方法。
在这里提一下：
有头结点和没有头结点的头插法写法是不一样的，而尾插法写法是一样的
有头结点的头插法：

node *head;//头结点
head->next=NULL;
node *newnode=(node *)malloc(sizeof(node));
newnode->next=head->next;
head->next=newnode;

没有头结点的头插法：

node *p;//首元节点
p->elem=xxx;
p->next=NULL;
node *newnode=(node *)malloc(sizeof(node));
newnode->next=p;
p=newnode;

无论是否有头结点的尾插法：

node *end=NULL;//尾指针
node *head=(node *)malloc(sizeof(node));//有头结点
//只有首元结点则node *p=(node *)malloc(sizeof(node));和上面一样
head->next=NULL;
end=head;
node *newnode=(node *)malloc(sizeof(node))
end->next=newnode;
end=newnode;

代码如下：

#include<stdio.h>
#include<stdlib.h>
typedef struct Node{
	int elem;
	struct Node *next;
}node;
node *initNode(){
	node *end=NULL;
	node *p=(node *)malloc(sizeof(node));
	p->next=NULL;
	p->elem=1;
	end=p;
	for(int i=2;i<4;i++){
		node *newnode=(node *)malloc(sizeof(node));
		newnode->next=NULL;
		newnode->elem=i;
		end->next=newnode;
		end=newnode;
	}
	return p;
}
void show(node *p){
	node *temp=p;
	while(temp){
		printf("%d ",temp->elem);
		temp=temp->next;
	}
	printf("\n");
}
node *head(node *p){
	node *new_p=NULL;
	node *temp=NULL;
	if(p==NULL||p->next==NULL){
		return p;
	}
	while(p){
		temp=p;
		p=p->next;
		temp->next=new_p;
		new_p=temp;
	}
	return new_p;
}
int main(void){
	node *p=initNode();
	show(p);
	p=head(p);
	show(p);
	return 0;
}

注意一点：

while(p){
		temp=p;
		p=p->next;
		temp->next=new_p;
		new_p=temp;
	}

这部分代码中，p=p->next必须在temp=p后面，如果放在最后面，由于
temp->next=new_p，使得temp指向的结点到后面所有结点的链断了（因为该节点的指针域不指向后面而指向new_p了），但是此时p也指向该结点，所以，此时的p=p->next为NULL（因为断链了）

方法4：在原链表上直接反转
思路是这样的：我们需要创建两个指针，如下图（图中有一个头指针p没画出来）。然后把第二个结点移除，操作类似于删除结点，就是让第一个结点的指针域指向第三个结点，
即pre->next=end->next，然后让第二个结点指向第一个结点，
即end->next=p，然后p指向end，接下来让end指针指向pre->next，即第三个结点。一直循环下去，直到end为NULL。

在这里插入图片描述

代码如下：

#include<stdio.h>
#include<stdlib.h>
typedef struct Node{
	int elem;
	struct Node *next;
}node;
node *initNode(){
	node *end=NULL;
	node *p=(node *)malloc(sizeof(node));
	p->next=NULL;
	p->elem=1;
	end=p;
	for(int i=2;i<4;i++){
		node *newnode=(node *)malloc(sizeof(node));
		newnode->next=NULL;
		newnode->elem=i;
		end->next=newnode;
		end=newnode;
	}
	return p;
}
void show(node *p){
	node *temp=p;
	while(temp){
		printf("%d ",temp->elem);
		temp=temp->next;
	}
	printf("\n");
}

			pre=mid;
			mid=end;
			end=end->next;
		}
		p=mid;
		return p;
	}
}
node *recursion(node *p){
	if(p==NULL||p->next==NULL){
		return p;
	}else{
		node *newnode = recursion(p->next);
		p->next->next=p;
		p->next=NULL;
		return newnode;
	}
}
node *head(node *p){
	node *new_p=NULL;
	node *temp=NULL;
	if(p==NULL||p->next==NULL){
		return p;
	}
	while(p){
		temp=p;
		p=p->next;
		temp->next=new_p;
		new_p=temp;
	}
	return new_p;
}
node *local(node *p){
	node *pre=NULL;
	node *end=NULL;
	if(p==NULL||p->next==NULL){
		return p;
	}
	pre=p;
	end=p->next;
	while(end){
		pre->next=end->next;
		end->next=p;
		p=end;
		end=pre->next;
	}
	return p;
}
int main(void){
	node *p=initNode();
	show(p);
	p=recursion(p);
	show(p);
	p=head(p);
	show(p);
	p=local(p);
	show(p);
	return 0;
}
blast_dragon
关注
  • 22
    点赞
  • 踩
  • 136
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C语言两种方法实现单链表反转（迭代与递归）
m0_63666616的博客
04-25 4543
C语言两种方法实现单链表反转（迭代与递归）
c语言实现单链表算法示例分享
09-04
主要介绍了c语言实现单链表算法示例,需要的朋友可以参考下
C语言 单链表的反转
热门推荐
Genven_Liang的博客
05-18 2万+
C语言 单链表的反转 一、简述 记--简单的将单链表的数据顺序进行反转。如将原来的顺序1 2 3 4 5 6 7 反转为：7 6 5 4 3 2 1 二、方式1：头插法 2.1 头插法1--类似新建链表 2.1.1 思路：断开链表头，然后以头插法的方式将原链表的数据添加链表。 2.1.2 测.........
【数据结构】反转单向链表的方法之头插法（含原理讲解及代码实现）
m0_53133879的博客
08-29 1084
将单向链表进行反转的方法很多，这里我们讲解一种比较简单的方法——头插法
【C补充】单向链表的反转（4种方法）
qq_43194080的博客
08-13 1036
介绍反转单向链表的几种方法
反转链表的四种方法（C语言）
Patrick_yuxuan的博客
12-03 3127
新建链表法，递归，迭代，原地反转。
C语言实现单链表实现方法
12-31
C语言实现单链表实现方法 链表和我们之前实现过的顺序表一样，都是简单的数据结构，链表分为单向链表、双向链表、循环链表。而单向链表又分为两种实现方法，一种为带头节点的单链表，一种为不带头节点的单链表。我们来具体看看不带头节点的单链表的实现 单链表：它是一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称存储单元为一个节点。 今天我们来实现一些单链表的简单接口 先看看单链表的结构： （为了通用性，我们将类型重命名为DataType） typedef int DataType; //链表 typedef struct Node { DataType *data; s
【BM2 链表内指定区间反转】
Sugar_wolf的博客
05-26 698
描述 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)。 例如： 给出的链表为 ：1→2→3→4→5→NULL, m = 2, n = 4 返回 1→4→3→2→5→NULL. 数据范围： 链表长度 0 < size ≤ 1000，0 < m ≤ n ≤ size，链表中每个节点的值满足 ∣val∣ ≤ 1000 要求：时间复杂度 O(n) ，空间复杂度 O(n) 进阶：时间复杂度 O(n)， 空间复杂度 O(1
C语言：反转链表
weixin_43936250的博客
12-16 1824
思路： 1.迭代： 迭代法反转链表需要3个指针，一个是当前指针head，一个是它的前节点newhead，一个是它的后节点next。 前节点是为了构造新的链，而后节点是为了与原来的链保持联系。newhead初始化为空，next初始化为头节点的next。 令head指向newhead，然后使newhead指向这个新链。这时head与原来的链断开，next就发挥了作用，令head指向next，然后nex...
反转链表的四种方法
weixin_45841522的博客
05-07 1万+
一 . 新建链表法 定义一个头节点，遍历链表，运用头插法将每个节点通过头节点插入道新建链表中。 总结： 1个头结点，2个指针（包含一个临时保存节点的pNex） struct ListNode* reverseList(struct ListNode* head){ //定义一个头节点 struct ListNode* Newhead; Newhead = (struct Lis...
C语言——反转链表
qq_57090911的博客
10-20 2245
大家好，本人第一次发布博客，目前正在学习数据结构，写博客的目的是一是想分享自己的学习过程，二也是每次写完代码后进行总结。希望大家一起共同学习！ 现在我正在看《大话数据结构》这本书，每次学习过后我都会去做一些与我看书内容相关的题目以此来巩固本次学习。 链表就是我学习的第一课，今天我分享的是有关反转链表的代码。 链表，其实我认为是在发现数组的不足之后进一步改进的，数组的定义大家应该都知道，那不就是一个数据一个数据顺序排嘛，但数组有个缺点，就是无法开辟空间，也就是说一个数组只...
C语言实现单链表反转
08-18
主要介绍了C语言实现单链表反转，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
c语言单向链表的反转思路,单链表的反转（C语言）
weixin_39657300的博客
05-21 490
单链表反转(C语言)方法一：三指针法思路：a,b,c三个指针分别指向三个位置a指针和b指针用来反转两个结点c指针指向下一个节点用来标记和向前推进代码//单链表反转函数//三指针法/*a,b,c三个指针分别指向三个位置，a指针和b指针用来反转两个结点，c指针指向下一个节点用来标记和向前推进。*/list *reverse_ThreePoints1(list *head){list *a,*b,*c;...
c语言实现单链表的反转
安权_code的博客
11-06 938
在c语言中，数组可以反转，字符串也可以逆序，因此链表也是可以进行反转的，反转链表是一个很经典的问题，但是其思路其实很简单。比如给一个单链表头节点plist，让plist的链表进行如下的反转：
反转链表（3种实现方法+图文解释+代码）
weixin_52514564的博客
04-27 551
递归（深度优先）遍历到最底层，然后逐级往上进行反转，每一次递归内部，将当前节点的next节点的next节点指向自身，同时将自身的next节点指向NULL（为了在最后一次递归时候，不让链表形成闭环）。建立链表1和链表2，循环遍历链表1，在每一个循环内部，将链表1的当前节点接入到链表2的头节点。图中是两种图形描述，代码是一样的，图形化理解方式不一样。将一个个数据推入栈区，然后再一个个弹出来。注意点：弹出完成之后，要把最后一个节点的next指向null，否则链表就闭环了。
链表——反转链表
m0_56709806的博客
07-05 1003
四种链表反转实现方法
C语言两种方法实现单链表反转
fatherofli的博客
05-05 4305
C语言两种方法实现单链表反转（迭代法、递归法）
单链表的反转（C语言实现）
qq_37406462的博客
09-25 2443
链表的反转或者说逆序的核心思想：遍历链表将所有节点依次摘链，并重新挂在链表头。 假设我们有一个链表，如图 A节点本身就是头节点，所以不必将其再摘链，挂链 所以第一步我们将B节点提到最前面 这个时候C节点变成了A节点的后继节点，我们需要把C节点提到最前面 这样D节点成了A节点的后继节点，依次类推，我们每次只需要将A节点的后继节点摘链并提到最前面即可完成整个链表的反转。 关键代...
C语言如何⽤指针为函数传递数组？
最新发布
PAP
04-25 312
C语言如何⽤指针为函数传递数组？
用C语言实现单链表递归反转，并附带解释
04-19
好的，可以开始讨论如何用C语言实现单链表递归反转。 首先，我们需要了解单链表和递归的概念。单链表是由一系列节点组成的数据结构，每个节点都包含一个数据元素和一个指向下一个节点的指针。递归则是一种通过函数自身不断调用来解决问题的方法。 在单链表中，反转的关键在于修改每个节点的指针指向前一个节点。而递归则可以通过不断递归到链表尾部，并在回溯的过程中修改指针来完成反转。 下面是用C语言实现单链表递归反转的代码： ``` #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; struct Node* reverse(struct Node* head) { if (head == NULL || head->next == NULL) { return head; } struct Node* newHead = reverse(head->next); head->next->next = head; head->next = NULL; return newHead; } int main() { struct Node* head = NULL; // 创建链表 head = (struct Node*)malloc(sizeof(struct Node)); head->data = 1; head->next = (struct Node*)malloc(sizeof(struct Node)); head->next->data = 2; head->next->next = (struct Node*)malloc(sizeof(struct Node)); head->next->next->data = 3; head->next->next->next = (struct Node*)malloc(sizeof(struct Node)); head->next->next->next->data = 4; head->next->next->next->next = NULL; // 反转链表 head = reverse(head); // 打印链表 while (head != NULL) { printf("%d ", head->data); head = head->next; } return 0; } ``` 在上面的代码中，我们定义了一个Node结构体来表示节点，其中包括了数据和指向下一个节点的指针。reverse函数通过递归来实现链表反转，并返回反转后的新头节点。在递归的过程中，我们先递归到链表尾部，然后在回溯的过程中修改每个节点的指针，实现链表反转。 希望这个例子能帮助您更好地理解单链表递归反转的原理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值