C语言 单链表的反转

已于 2022-06-05 19:40:59 修改
阅读量2.6w 收藏 251
点赞数 59
分类专栏： C 文章标签： C语言 单链表的反转
于 2019-05-18 22:41:09 首次发布
学习笔记
本文链接：https://blog.csdn.net/nanfeibuyi/article/details/90116419
版权

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 测试代码

#include <stdio.h>
#include <stdlib.h>

//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;

Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_head(Node* head, Node* new_node);
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i<8; i++)
		add_node_head(head, create_new_node(i));

	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	return 0;
}

//创建链表 
Node* create_list_head()
{
	Node* head = (Node*)malloc(sizeof(Node));
	if(NULL != head)
	{
		head->data= -1;
		head->pNext= NULL;	
	}
	return head;
} 

//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}

//头插法
int add_node_head(Node* head, Node* new_node)
{
	if(NULL == head || NULL == new_node)
		return -1;
 	new_node->pNext = head->pNext;
	head->pNext = new_node;
	return 0; 
} 

//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL !=(tmp=tmp->pNext))
	{
		printf("%d  ", tmp->data);
	}
	printf("\n");
}

//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while(p = p->pNext)
	{
		head->pNext = p->pNext;
		//printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
	free(head);
} 

//头插方式1-反转链表 
Node* revert_list(Node* head)
{
	if(NULL == head)
		return;

	Node* p = head->pNext;
	head->pNext= NULL;
	Node* tmp = NULL;
	while(p)
	{
		tmp = p->pNext;
		add_node_head(head, p); 
		p = tmp;	
	}
	
	return head;
}

        2.1.3 测试结果

              

        2.2 头插法2 --与方式1雷同

         2.2.1 思路：除了第一个逐个往插入到最前面

         2.2.2 测试代码

#include <stdio.h>
#include <stdlib.h>

//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;

Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_head(Node* head, Node* new_node);
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i<8; i++)
		add_node_head(head, create_new_node(i));

	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	return 0;
}

//创建链表 
Node* create_list_head()
{
	Node* head = (Node*)malloc(sizeof(Node));
	if(NULL != head)
	{
		head->data= -1;
		head->pNext= NULL;	
	}
	return head;
} 

//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}

//头插法
int add_node_head(Node* head, Node* new_node)
{
	if(NULL == head || NULL == new_node)
		return -1;
 	new_node->pNext = head->pNext;
	head->pNext = new_node;
	return 0; 
} 

//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL !=(tmp=tmp->pNext))
	{
		printf("%d  ", tmp->data);
	}
	printf("\n");
}

//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while(p = p->pNext)
	{
		head->pNext = p->pNext;
		//printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
	free(head);
} 

//新建链表方式-反转链表 
Node* revert_list(Node* head)
{
	if(NULL == head)
		return;
	
	Node* p = head->pNext;
	Node* q = NULL;
	while(q = p->pNext)
	{
		p->pNext = q->pNext;//分离q 
		add_node_head(head, q);//将q插入到首元素位置 
	}
	
	return head;
}

         2.2.3 测试结果

     

 三、方式2 尾插方式

        3.1 思路：找到最后一个元素，然后从第一个元素逐个插入到尾部。

        3.2 测试代码

#include <stdio.h>
#include <stdlib.h>
 
//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;
 
Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_tail(Node* head, Node* new_node); 
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i<8; i++)
		add_node_tail(head, create_new_node(i));
 
	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	return 0;
}
 
//创建链表 
Node* create_list_head()
{
	Node* head = (Node*)malloc(sizeof(Node));
	if(NULL != head)
	{
		head->data= -1;
		head->pNext= NULL;	
	}
	return head;
} 
 
//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}
 
//尾插法 
int add_node_tail(Node* tail, Node* new_node)
{
	if(NULL == tail || NULL == new_node)
		return -1;	
	new_node->pNext = tail->pNext; //新节点指向原来的tail->pNext
	tail->pNext = new_node;//新节点成为tail->pNext 
	return 0;
} 
 
//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL !=(tmp=tmp->pNext))
	{
		printf("%d  ", tmp->data);
	}
	printf("\n");
}
 
//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while(p = p->pNext)
	{
		head->pNext = p->pNext;
		//printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
	free(head);
} 
 
//尾插方式-反转链表 
Node* revert_list(Node* head)
{
	if(NULL == head)
		return;
	
	Node *p = head->pNext, *end = head;
	while( NULL != end->pNext )//使得end指向链表最后一个元素
	{
		end = end->pNext;
	}
	 
	while(p != end)
	{
		head->pNext = p->pNext;//分离p
		add_node_tail(end, p);//将p插入到末尾位置
		p = head->pNext;//p指向第一个元素 
	}
	
	return head;
}

        3.3 测试结果

四、方法3 递归反转 

 1、递归结束边界：节点为NULL, 或当前节点指向NULL

 2、状态转移方程：反转(1到N) = 先反转(1到N-1)，再将N添加到尾部

测试代码：（注意，本例子与上面的例子稍有差异，为了方便表述，头节点也作为使用并存储数据了）

#include <stdio.h>
#include <stdlib.h>
 
#define NODE_COUNT	3
 
//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;
 
Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_tail(Node* head, Node* new_node); 
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i < NODE_COUNT; i++)
		add_node_tail(head, create_new_node(i));
 
	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	
	getchar();
	return 0;
}
 
 
//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}
 
//创建链表 
Node* create_list_head()
{
	return create_new_node(NODE_COUNT); 
}
 
//尾插法 
int add_node_tail(Node* tail, Node* new_node)
{
	if(NULL == tail || NULL == new_node)
		return -1;	
	new_node->pNext = tail->pNext; //新节点指向原来的tail->pNext
	tail->pNext = new_node;//新节点成为tail->pNext 
	return 0;
} 
 
//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL != tmp)
	{
		printf("%d  ", tmp->data);
		tmp = tmp->pNext;
	}
	printf("\n");
}
 
//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while (p) {
		head = head->pNext;
		printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
} 
 
//反转链表 
Node* revert_list(Node* head)
{
	if (NULL == head || NULL == head->pNext) {
		return head;
	}
	
	Node* new_head = revert_list(head->pNext);
	
	head->pNext->pNext = head;
	head->pNext = NULL;
	
	return new_head;
}

 测试结果：

Genven_Liang
关注
专栏目录
C语言两种方法实现单链表反转（迭代与递归）
m0_63666616的博客
04-25 4644
C语言两种方法实现单链表反转（迭代与递归）
【数据结构 C语言版】第三篇 单链表习题_数据结构c语言 单链表题
2401_84182271的博客
04-30 972
方法一代码题解（方法二）（1）翻转方向（2）代码实现细节图解方法二代码。
C语言：反转链表
weixin_43936250的博客
12-16 2028
思路： 1.迭代： 迭代法反转链表需要3个指针，一个是当前指针head，一个是它的前节点newhead，一个是它的后节点next。 前节点是为了构造新的链，而后节点是为了与原来的链保持联系。newhead初始化为空，next初始化为头节点的next。 令head指向newhead，然后使newhead指向这个新链。这时head与原来的链断开，next就发挥了作用，令head指向next，然后nex...
【算法思想·链表】单链表的花式反转方法汇总
最新发布
Captain823Jack的博客
08-23 825
反转单链表的迭代解法不是一个困难的事情，但是递归实现就有点难度了。如果再加一点难度，让你仅仅反转单链表中的一部分，你是否能够同时用迭代和递归实现呢？再进一步，如果让你 k 个一组反转链表，阁下又应如何应对？本文就来由浅入深，一次性解决这些链表操作的问题。我会同时使用递归和迭代的方式，并结合可视化面板帮助你理解，以此强化你的递归思维以及操作链表指针的能力。2、反转整个单链表# 单链表节点的结构单链表反转是一个比较基础的算法题，力扣第 206 题「反转链表」就是这个问题。迭代解法。
单链表的反转（C语言实现）
qq_37406462的博客
09-25 2508
链表的反转或者说逆序的核心思想：遍历链表将所有节点依次摘链，并重新挂在链表头。 假设我们有一个链表，如图 A节点本身就是头节点，所以不必将其再摘链，挂链 所以第一步我们将B节点提到最前面 这个时候C节点变成了A节点的后继节点，我们需要把C节点提到最前面 这样D节点成了A节点的后继节点，依次类推，我们每次只需要将A节点的后继节点摘链并提到最前面即可完成整个链表的反转。 关键代...
c语言实现单链表的反转
安权_code的博客
11-06 1506
在c语言中，数组可以反转，字符串也可以逆序，因此链表也是可以进行反转的，反转链表是一个很经典的问题，但是其思路其实很简单。比如给一个单链表头节点plist，让plist的链表进行如下的反转：
单链表反转C语言实现
热门推荐
零丁若叹
07-05 1万+
单链表的反转可以使用循环，也可以使用递归的方式 1.循环反转单链表 循环的方法中，使用pre指向前一个结点，cur指向当前结点，每次把cur->next指向pre即可。 代码： # include # include using namespace std; struct linkNode { int val; linkNode *next; linkNode(int...
单链表反转
m0_37709009的博客
03-15 289
http://c.biancheng.net/view/8105.html
C语言实现单链表反转
08-18
"C语言实现单链表反转" C语言实现单链表反转是指在C语言中实现单链表的反转操作，即将链表的结点顺序颠倒过来。这个操作需要对指针有深入的理解，否则很容易出现指针丢失和内存泄漏的问题。 一、理解指针 要想写...
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
在C语言中，单链表是一种基础且重要的数据结构，它在编程中有着广泛的应用。本文将详细解析如何使用C语言来实现单链表，并涵盖了19种不同的操作功能，帮助你深入理解这一核心概念。 单链表由一系列节点组成，每个...
单链表反转java代码
weixin_30379911的博客
09-08 125
据说单链表反转问题面试中经常问，而链表这个东西相对于数组的确稍微难想象，因此今天纪录一下单链表反转的代码。 1，先定义一个节点类。 1 public class Node { 2 int index; 3 Node next; 4 5 public Node(int index, Node next) { 6 this.index = ind...
反转链表C实现
06-14
反转链表C实现
单链表反转（C语言）
grh526zjz的博客
12-16 645
单链表反转（C语言） 方法一：三指针法 思路： a,b,c三个指针分别指向三个位置 a指针和b指针用来反转两个结点 c指针指向下一个节点用来标记和向前推进 代码 //单链表反转函数 //三指针法 /* a,b,c三个指针分别指向三个位置， a指针和b指针用来反转两个结点， c指针指向下一个节点用来标记和向前推进。 */ list *reverse_ThreePoints1(l...
反转单链表（C语言）
珂珂可爱多
04-04 1708
描述 给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 数据范围：0\leq n\leq10000≤n≤1000 要求：空间复杂度O(1)O(1)，时间复杂度O(n)O(n)。 如当输入表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 以上转换过程如下图所示： /** * struct ListNode { * int val; * stru...
C语言两种方法实现单链表反转
fatherofli的博客
05-05 4397
C语言两种方法实现单链表反转（迭代法、递归法）
【BM2 链表内指定区间反转】
Sugar_wolf的博客
05-26 807
描述 将一个节点数为 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语言）
Butayarou的博客
01-06 4498
题目描述： 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例2： 输入：head = [] 输出：[] 题目来源（力扣）：反转链表
c语言代码反转单链表,C语言反转单链表
weixin_39769627的博客
05-22 288
反转单链表定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。链表结点定义如下：struct node{int val;struct node *pNext;};#include #include struct node{int val;struct node *pNext;};struct node *gen(){struct node *pHead = NULL;for(i...
单链表反转C语言代码
qq_42108074的博客
02-05 639
单链表反转C语言代码
链表c语言代码 反转函数,单链表反转C语言实现
06-10
好的，下面是单链表反转的C语言实现代码： ```c #include<stdio.h> #include<stdlib.h> struct ListNode { int val; struct ListNode *next; }; struct ListNode* reverseList(struct ListNode* head) { struct ListNode* prev = NULL; struct ListNode* curr = head; while (curr != NULL) { struct ListNode* nextTemp = curr->next; curr->next = prev; prev = curr; curr = nextTemp; } return prev; } int main() { struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode)); head->val = 1; head->next = (struct ListNode*)malloc(sizeof(struct ListNode)); head->next->val = 2; head->next->next = (struct ListNode*)malloc(sizeof(struct ListNode)); head->next->next->val = 3; head->next->next->next = NULL; struct ListNode* new_head = reverseList(head); while (new_head != NULL) { printf("%d ", new_head->val); new_head = new_head->next; } return 0; } ``` 这段代码中，我们首先定义了一个 `ListNode` 结构体，表示单链表的节点。其中，`val` 表示节点的值，`next` 表示指向下一个节点的指针。接着，我们定义了 `reverseList` 函数，用于反转单链表。在函数中，我们使用了三个指针变量 `prev`、`curr` 和 `nextTemp`，分别表示当前节点的前一个节点、当前节点和当前节点的后一个节点。在循环中，我们不断地将当前节点的 `next` 指针指向前一个节点，然后更新三个指针变量的值，直到当前节点为 `NULL`。最后，我们返回反转后的单链表的头指针 `prev`。在 `main` 函数中，我们构造一个简单的单链表，并且调用 `reverseList` 函数进行反转，最后输出反转后的单链表的节点值。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值