C++ 链表的递归逆转和循环逆转

最新推荐文章于 2025-04-07 15:10:25 发布
原创 最新推荐文章于 2025-04-07 15:10:25 发布 · 1.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种链表数据结构的实现方式，并提供了添加元素到链表末尾的方法。此外，还展示了两种不同的链表遍历方法：递归与非递归方式。更重要的是，详细解释了如何使用递归方法来反转链表，并通过示例代码演示了整个过程。

算法比较菜，没算法天赋呀。。。得多写。。。  

struct node {
	int a;
	node * pnext;
} ;

void addlist(node * phead,int a)
{
	if(phead == NULL)
		return ;
	while (phead->pnext != NULL)
	{
		phead = phead ->pnext ;
	}
	node * p = new node;
	p->a = a;
	p->pnext = NULL ;
	phead->pnext = p;
}

void DisplayListRecursive(node * phead)
{
	if(phead == NULL   )
		return ;
	DisplayListRecursive(phead->pnext);
	printf("%d \n",phead->a);
}

void DisplayList(node * phead)
{
	if(phead == NULL)
		return ;
	while(phead != NULL)
	{
		printf("%d \n",phead->a);
		phead = phead->pnext ;
	}
}

node * RecursiveList(node * phead)
{
	node * p1,*p2,*p3 ;

	if(phead==NULL)
		return NULL;

	if(phead->pnext == NULL)
		return phead ;

	p1 = phead;
	p2 = p1->pnext ;
	p3 = p2->pnext ;
	phead->pnext = NULL ;

	while(p3 != NULL)
	{
		p2->pnext = p1 ;
		p1 = p2 ;
		p2 = p3 ;
		p3 = p3->pnext ;
	}
	p2->pnext = p1;
	return p2 ;
}

node * RecursiveListE(node * phead)
{
	if(phead == NULL || phead->pnext == NULL )
		return phead ;
	else
	{
		node * pnewhead = RecursiveListE(phead->pnext ) ; 
		phead->pnext->pnext = phead ;
		phead->pnext = NULL ;
		return pnewhead ;
	}
}
int main(int argc, char* argv[])
{
	node * head = new node;
	head->a = 0 ;
	head->pnext = NULL;
	addlist(head,1);
	addlist(head,2);
	addlist(head,3);
	addlist(head,4);
	DisplayList(RecursiveListE(head));
	return 0;
}


xjay_cc
关注
C/C++ 递归实现链表的逆转算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-06 7615
递归实现链表的逆转算法是一种通过反复调用自身来解决问题的方法。其基本思想是将链表分为两部分，当前节点和剩余部分。首先反转剩余部分，然后将当前节点加入到反转后链表的末尾。递归实现链表的逆转算法的优点是代码简洁，易于理解。它能够反转任意长度的链表，并且不需要额外的空间。缺点是递归的深度与链表长度成正比，对于非常长的链表可能导致堆栈溢出。
C++用递归实现链表的逆转(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-18 547
C++用递归实现链表的逆转C++用递归实现链表的逆转算法完整源码(实现，main函数测试） C++用递归实现链表的逆转算法完整源码(实现，main函数测试） #include <iostream> using namespace std; struct node { int val; node *next; }; node *start; void insert(int x) { node *t = start; if (start != NULL) {
链表的逆转的实现（c++语言）
04-06
链表逆转问题的c++语言实现方法，比较简单
逆转链表
dianlu7964的博客
09-22 200
正确写法： Node* reverse(Node* head) { Node* current = head; Node* reversList = null; while(current) { /*将当前节点取出原链表迅速改变current(即current取出!!!注 意这是 一个赋值操作，赋值完后cu...
使一个循环单链表逆转
06-07
C++ 实验 包含3个文件reverse.cpp CirHSLinkedList.h Node.h
单向循环链表反转
storylike的专栏
11-09 1813
<br />昨天面试被问到单向循环链表的反转问题，以前没有考虑过这个问题，答得不是很好，晚上回去仔细想了想，又在网上找了找，总结出以下几种方法：<br />1、利用两个额外变量的情况：<br />node* reverse(node *head) { if(head == NULL || head->next == NULL) { return head; } node *cur = head;
循环列表的逆转
honeylife的博客
08-12 335
循环列表的逆转 题目 已知带头结点的循环列表的头结点指针为list，请别写一个算法，逆转链表链接的方向。 代码 // 逆转链表的链接方向 void CHANGEOVER(LinkList list){ LinkList p,q,r; p=list->link; q=list; while (p!=list) { r=q;...
[学习笔记]链表逆转--递归法
qq_45687653的博客
10-24 738
递归具有递推和回归的两个阶段，而此处运用的恰好就是其回归阶段，以此实现链表的尾->头访问来重新连接节点实现链表逆转。逆转链表对于链表每个节点来说,都需要将下一个节点指向自己,自己指向空.链表逆转后,最后一个节点成为新的链表头,回归时需要带回。直接或间接的调用本身直到终止条件回归。第一种:链表为空,或只有一个节点.第二种:递归到链表末尾.则返回值就是新的链表头。
C++链表
Simon的博客
09-28 1052
一、 基本特征: 内存中不连续的节点序列, 节点之间通过next指针彼此相连; 每个节点的next指针都指向下一个节点,最后一个节点的next指针为NULL. 二、基本操作: 插入、删除、遍历 三、形式: 单向链表, 双向链表, 单向循环链表, 双向循环链表 四、实现要点: 追加: 将新分配节点的地址赋给原链表尾端节点的next指针 插入: 将前节点中存储的后节点地址赋给新节点的next指针,将新节点的地址赋给前节点的next指针 删除: 将前节点的next指针赋值为待删除节点的next指针, 对于单向链表
C++语言的链表反转
2501_91512405的博客
04-07 1018
本文详细介绍了链表的基本概念、反转算法以及C++实现。在实际开发中，链表反转常用来解决不同的业务需求，比如在一些排序算法或查找算法中，都可能需要对链表进行反转。
C++反转链表递归
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
10-25 473
反转链表的递归解法
【C++算法】：反转链表
W_Oilpicture的博客
09-03 3325
【代码】【C++算法】：反转链表。
单向链表逆转(递归)
brucehb的专栏
11-22 728
struct Node { int value; Node *next; }; //head为原始链表的头节点，p初始值为head，newHead用来存储逆转后的头节点 void reverse(Node *head,Node *p, Node* &newHead) { if (NULL == head) { newHead = NULL;
Leetcode #92. 反转链表 II（c++）递归
qq_40999273的博客
04-23 325
Leetcode 92. 反转链表 II 难度中等352收藏分享切换为英文关注反馈 反转从位置m到n的链表。请使用一趟扫描完成反转。 说明: 1 ≤m≤n≤ 链表长度。 示例: 输入: 1->2->3->4->5->NULL, m = 2, n = 4 输出: 1->4->3->2->5->NULL 自己用...
反转链表 C++ 迭代 递归
qq_33894666的博客
07-23 1138
反转链表 LeeCode206.反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 解法一：迭代 prev指向前一个节点，初始化为nullptr，使链表第一个节点指向nullptr。cur指向当前正在遍历的节点，每次都使cur->next指向prev，然后prev指向cur。在此之前，要保存cur->next，用tmp保存，最后，cur指向tmp。 class Solution { public: ListNode* reverseList(ListNod
C++实现算法题之反转链表
qq_42382539的博客
01-07 1201
题目：定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 示例： 输入 : 1->2->3->4->5->NULL 输出 : 5->4->3->2->1->NULL #include <algorithm> #include <unordered_map> #include <iostream> #include <vector> using namespace std; /
循环链表的反转
csdn_kou的博客
06-09 1704
206. 反转链表 func reverseList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } p := reverseList(head.Next) head.Next.Next = head head.Next = nil return p } 循环链表的反转 func reverse(head, key *ListN
链表逆转（递归+非递归）
蓝旭晨枫╮
04-06 474
将链表逆转。 非递归： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 /**  * Definition for
链表逆转的两种方法
dahongwudi的专栏
10-24 914
方法一递归的方式（体现了递归的思想） public Node reverseList(Node node) { if(node.next == null) {//当最后一个节点的时候返回 return node; } Node temp = node.next;//得到当前节点的下一个节点 Node ret
链表的逆转C++
最新发布
10-25
C++实现链表逆转有多种方法，以下为你介绍常见的几种： ### 递归法 递归法的思路是先递归反转剩余部分链表，再将当前节点加入到反转后链表的末尾。以下是示例代码： ```cpp #include <iostream> // 定义链表节点结构 typedef struct Node { int data; struct Node* next; } Node; // 递归反转链表 Node* reverseLinkedList(Node* head) { // 空链表或只有一个节点，直接返回 if (head == NULL || head->next == NULL) { return head; } // 递归反转剩余部分链表 Node* newHead = reverseLinkedList(head->next); // 将当前节点加入到反转后链表的末尾 head->next->next = head; // 当前节点成为新的末尾节点 head->next = NULL; return newHead; } // 打印链表 void printLinkedList(Node* head) { while (head != NULL) { std::cout << head->data << " "; head = head->next; } std::cout << std::endl; } int main() { // 构建一个链表：1 -> 2 -> 3 -> 4 -> 5 Node* head = NULL; for (int i = 5; i >= 1; i--) { Node* newNode = new Node; newNode->data = i; newNode->next = head; head = newNode; } std::cout << "原始链表："; printLinkedList(head); head = reverseLinkedList(head); std::cout << "逆转后链表："; printLinkedList(head); return 0; } ``` 此方法先判断链表是否为空或只有一个节点，若是则直接返回。接着递归反转剩余部分链表，再调整当前节点的指向，最后返回新的头节点[^2]。 ### 迭代法 迭代法通过三个指针 `beg`、`mid` 和 `end` 来遍历链表并修改节点的指向。示例代码如下： ```cpp #include <iostream> // 定义链表节点结构 struct link { int data; link* next; link(int val) : data(val), next(nullptr) {} }; // 迭代反转链表 link* reverse(link* head) { if (head == nullptr || head->next == nullptr) return head; link* beg = nullptr; link* mid = head; link* end = head->next; // 遍历 while (true) { // 修改mid所指节点的指向beg mid->next = beg; // 判断end是否最后了 if (end == nullptr) break; // 调整向后移动 beg = mid; mid = end; end = end->next; } // 修改head头指针的指向 head = mid; return head; } // 打印链表 void printLinkedList(link* head) { while (head != nullptr) { std::cout << head->data << " "; head = head->next; } std::cout << std::endl; } int main() { // 构建一个链表：1 -> 2 -> 3 -> 4 -> 5 link* head = new link(1); link* current = head; for (int i = 2; i <= 5; i++) { current->next = new link(i); current = current->next; } std::cout << "原始链表："; printLinkedList(head); head = reverse(head); std::cout << "逆转后链表："; printLinkedList(head); return 0; } ``` 该方法使用三个指针遍历链表，不断修改节点的指向，最后调整头指针的指向完成反转[^3]。 ### 双向链表逆序输出法 对于双向链表，创建好之后选择逆序方式进行输出即可。示例代码如下： ```cpp #include <iostream> // 定义双向链表节点结构 struct node { int data; node* before; node* next; node(int val) : data(val), before(nullptr), next(nullptr) {} }; // 逆序输出双向链表 void print(node*& end) { for (node* p = end; p->before; p = p->before) { std::cout << p->data << " "; } std::cout << std::endl; } int main() { // 构建一个双向链表：1 <-> 2 <-> 3 <-> 4 <-> 5 node* head = new node(1); node* current = head; node* end = nullptr; for (int i = 2; i <= 5; i++) { node* newNode = new node(i); current->next = newNode; newNode->before = current; current = newNode; if (i == 5) { end = newNode; } } std::cout << "逆序输出双向链表："; print(end); return 0; } ``` 该方法适用于双向链表，通过逆序遍历双向链表实现反转输出[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值