递归反转栈

最新推荐文章于 2025-09-12 21:02:09 发布
原创 最新推荐文章于 2025-09-12 21:02:09 发布 · 227 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Median of Two Sorted Arrays 两个有序数组的中位数leetcode
https://www.cnblogs.com/grandyang/p/4465932.html
[LeetCode] Invert Binary Tree 翻转二叉树
https://www.cnblogs.com/grandyang/p/4572877.html
leetcode移除有序链表中的重复项之二
https://www.cnblogs.com/grandyang/p/4069003.html
递归反转栈
https://www.cnblogs.com/4everlove/p/3666016.html

BIGO-机器学习算法工程师
https://www.nowcoder.com/discuss/255042?type=2&order=0&pos=16&page=1
https://www.nowcoder.com/discuss/239639?type=2&order=0&pos=54&page=1
https://www.nowcoder.com/discuss/238325?type=2&order=0&pos=70&page=1
https://www.nowcoder.com/discuss/238019?type=2&order=0&pos=69&page=1
https://www.nowcoder.com/discuss/242777?type=2&order=0&pos=53&page=1
https://www.nowcoder.com/discuss/243474?type=2&order=0&pos=50&page=1
https://www.nowcoder.com/discuss/243829?type=2&order=0&pos=44&page=1
https://www.nowcoder.com/discuss/243488?type=2&order=0&pos=39&page=1
https://www.nowcoder.com/discuss/238781?type=2&order=0&pos=34&page=1
https://www.nowcoder.com/discuss/252968?type=2&order=0&pos=24&page=1
https://www.nowcoder.com/discuss/246825?type=2&order=0&pos=10&page=1
https://www.nowcoder.com/discuss/260893?type=2&order=0&pos=2&page=1

使用递归反转一个栈
鱼思故渊的专栏
08-21 3819
反转递归栈的内容 使用递归，一定要明白递归结束的条件，假如栈中只有一个元素或者没有元素，那么这个栈就不用递归。那么我们将栈顶元素取出来，将余下的元素进行反转，那么将取出的元素放到栈的底部即可。 对于将一个元素放到底部，又是一个递归的调用，如果栈为空，那么直接将元素存放到栈的底部即可，如果栈中有元素，那么取出栈内的元素，将原来的元素再次调用函数存放到栈底，然后将取出的元素压入栈即可。 感觉这个
算法系列之递归反转单链表
修己xj的博客
02-25 626
递归反转链表的基本思路是将当前节点的next指针指向前一个节点，然后递归地对下一个节点进行同样的操作。递归的核心思想是将问题分解为更小的子问题，直到达到基本情况（通常是链表末尾）。
用递归颠倒栈
先疯盗骨
08-06 765
题目：用递归颠倒一个栈。例如输入栈{1, 2, 3, 4, 5}，1在栈顶。颠倒之后的栈为{5, 4, 3, 2, 1}，5处在栈顶。 分析：乍一看到这道题目，第一反应是把栈里的所有元素逐一pop出来，放到一个数组里，然后在数组里颠倒所有元素，最后把数组中的所有元素逐一push进入栈。这时栈也就颠倒过来了。颠倒一个数组是一件很容易的事情。不过这种思路需要显示分配一个长度为O(n)的数组，而且也没
递归反转栈的顺序-------只使用常数量个变量
码农小札
09-06 478
转载地址：http://www.cnblogs.com/4everlove/p/3666016.html 我们要反转一个栈，如果使用另外一个栈作为辅助的话，那么反转起来很简单，一个接一个push到辅助栈里再push回来就行了。那么假如不能使用辅助栈，数组等空间为O(n)的数据结构，只使用O（1）的空间复杂度即只能有常数个变量，怎么实现将栈反转？即原来的栈顶在栈底，栈底变成栈顶。   面试
递归地反转一个栈
realxie的专栏
10-03 6566
// // The code is used to reverse a stack recursively // #include #include using namespace std; // We can think about how we can reverse a stack with another stack. // Cause stack is a structure f
递归实现反转栈Java
weixin_43923436的博客
10-24 657
烧脑提醒！烧脑提醒！烧脑提醒！ 不皮了，下面开始正题。 题目要求：用递归实现栈反转。 我走的弯路： 首先，我刚开始的想法，我觉得，递归其实本质也是个栈类型的数据结构，所以可以利用递归过程的栈来实现反转。其实，这个思路有问题，因为你递归的过程中，其实也是在出栈操作，当你递归到栈底时，此时，递归函数中最后一个值也是栈底元素，此时，再入栈，其实又原路返回了，所以，必须在此基础上，再递归一次，我看到网上有这种解法，太恶心了，两个递归嵌套。其实这种解法并不是此题的本意，此题的本意是考查对递归思想的深入理解。 我的解法
如何使用递归和非递归方式反转单向链表
09-05
本篇文章将详细介绍如何使用递归和非递归两种方法来实现单向链表的反转。 首先，我们来看非递归的解决方案。非递归方法通常涉及到迭代，通过两个指针，`previousNode` 和 `nextNode`，来追踪和更新链表。初始时，`...
LeetCode 025. K个一组翻转链表 - 分组反转（头插法）、递归与栈详解
最新发布
m0_52114506的博客
09-12 1069
题目描述：给定一个链表的头节点 head 和一个正整数 k，每 k 个节点一组进行翻转，请返回翻转后的链表。若剩余节点数不足 k 个，则保持这些节点的原有顺序。原题链接：https://leetcode.cn/problems/reverse-nodes-in-k-group/难度等级：Hard相关标签：链表、双指针、递归、栈、分组反转。
反转链表（递归法）图文详解
zhaoyang_m的博客
10-27 1588
通过“先深入后返回”的策略，首先会一直递归调用自身，直到到达链表的尾部，并在递归的过程中改变节点之间的指向来实现链表的反转。具体步骤是先递归地反转子链表，然后将当前节点的下一个节点的指针指向当前节点，并将当前节点的指针指向空。具体步骤是使用三个指针分别指向当前节点、前一个节点和下一个节点，然后在遍历过程中不断更新这三个指针的指向，直到遍历到链表末尾。，意思 4 这个结点指向空结点，不再指向任何结点了，当然包括 5 这个结点。的知识去理解，搞清楚到底函数调用时，原本的参数值是什么。
Python-数据结构-栈-以递归的方式反转栈
qq_41188247的博客
12-10 505
Python-数据结构-栈-以递归的方式反转栈
菜鸟刷题之路——Q24：递归反转栈
yindarui
10-24 542
问题 只用递归实现一个栈的翻转，假设栈存储的内容是整数类型。 问题来自面试，主要是考量思想。 分析 分析：递归本身是调用系统栈，我们以1->2->3->4->5这个序列为例子，实现翻转需要两个过程： 弹出当前栈底元素，保存下来，并保持其他元素的位置不动。此时栈的大小是在不断变小的； 不断取出栈底元素直到栈空，此时我们取出的顺序是：1,2,3,4,5。我们只需要再递归地把它们压入栈就实现了栈的翻转。 Code // 弹出栈底元素，并保持其他元素位置不动 public in
递归反转栈，不借助额外数据结构
weixin_43923436的博客
05-24 275
题目描述 用递归反转栈，要求不能借助其他数据结构。 思路分析 递归其实就是系统栈，如果只是用递归，可以反转打印出原来栈中的元素，但是，题目要求是反转，就是把原来的栈颠倒过来。 因此，借助递归函数，再依次返回的时候，再依次入栈，就又回去了。因此，我们先用一个递归来找出栈底元素，然后，再用一个递归依次求出栈底，然后再依次入栈，就能实现反转了。 代码 public static void reverseStack(Stack<Integer> stack){ if(stack.
反转栈元素(递归算法实现)
ldbite的博客
02-21 314
#include #include using namespace std; void Reverse_stack(stack& st, int n, int tmp) { if (n == 0) return; tmp = st.top(); st.pop(); Reverse_stack(st, n - 1, tmp); st.push(tmp); } int main() { int...
用递归翻转一个栈ReverseStackUsingRecursive
JZ
10-10 6995
package class_06; import java.util.HashMap; import java.util.HashSet; import java.util.Map.Entry; /** * * Dijkstra算法 * 适用范围：没有权值为负数的边 * */ // no negative weight public class Code_06_Dijkstra { ...
用递归翻转一个栈 Reverse a stack using recursion
07-06 2520
明确递归语句之前的语句都是顺序执行，而递归语句之后的语句都是逆序执行package recursion; import java.util.Stack; public class Reverse_a_stack_using_recursion { /* Input stack: 3 2 1 Output stack: 1 2 3 */ public s
递归实现栈反转与栈排序
weixin_34051201的博客
11-02 159
牢记：递归是为了将原规模为n的问题变成较小的规模来处理 一、使用递归来反转一个栈，不允许生成O(n)空间来处理。 来做几个实例（略），n个数的栈步骤如下： 1. 取栈顶元素pop到temp1 2. 反转n-1个数的栈（规模为n-1,我们认为该较小规模可以处理） 3. 取栈顶元素pop到temp2 4. 反转n-2个元素的栈（当然认为是递归可以帮我们处理好的） 5...
用递归方式将栈内容翻转
brucehb的专栏
03-27 1053
比如：原来栈中从顶到底的元素分别为1, 2, 3, 4, 5。.翻转后栈中从顶到底应分别为5, 4, 3, 2, 1。 #include using namespace std; void addToStack(stack &buf, int value) {       if (buf.empty())       {           buf.push(value);
递归翻转栈&递归栈排序
行到水穷处，坐看云起时
06-20 2387
1 递归的翻转一个栈 2 递归的排序一个栈 两个操作均不借助其他数据结构 int in=0; // 入栈次数 int out=0; //出栈次数 // 不借助其他结构体，翻转一个栈中的元素，如 a,b,c -> c,b,a. static void ReverseStack(stack &st) { if (st.size() == 0)// 栈空，则返回 retu
递归反转一个栈
会呼吸的鱼
08-14 1528
递归反转一个栈，要求空间复杂度为1，不许重新申请一个同样的栈
请动态演示递归反转单链表
09-08
<think> 我们要求动态演示递归反转单链表，但作为文本模型，无法直接生成动画或视频。因此，我将用详细的步骤分解和图示（使用文本描述）来解释递归反转单链表的过程。同时，我会提供伪代码和递归每一步的栈状态，以便理解。 递归反转单链表的基本思想（参考引用[2][4]）： 1. 递归终止条件：如果链表为空或只有一个节点，则直接返回头节点（因为反转后还是自身）。 2. 递归步骤：先反转以头节点下一个节点开始的子链表，然后将当前头节点接在反转后的子链表的末尾，同时将头节点的next置为null。 递归函数定义（C语言风格）： ```c ListNode* reverseList(ListNode* head) { // 终止条件 if (head == NULL || head->next == NULL) { return head; } // 递归反转子链表（从head->next开始） ListNode* p = reverseList(head->next); // 将当前节点head接在反转后的子链表的末尾 head->next->next = head; head->next = NULL; return p; } ``` 现在，我们用一个小例子（链表1->2->3->4）来动态演示递归过程： 初始链表：1 → 2 → 3 → 4 → NULL 递归调用栈（从最深层开始返回时执行连接操作）： 步骤1：递归到底（head->next为NULL）开始返回 - 最后一次调用：head=4，满足终止条件，返回4。此时p=4，然后返回给上一层（head=3的那层）。 步骤2：head=3的递归层 - 执行p = reverseList(head->next) 得到p指向4（此时子链表已经反转，即4->3后面的部分已经反转好，但还没有调整3和4的指针） - 执行：head->next->next = head; 即3的下一个节点（4）的next指向3，也就是4->3 - 执行：head->next = NULL; 即3的next置空，此时4->3->NULL - 返回p（即4）给上一层（head=2） 步骤3：head=2的递归层 - 得到p=4（实际上此时反转后的子链表是4->3，头节点是4） - 执行：head->next->next = head; 即2的下一个节点（3）的next指向2，也就是3->2 - 执行：head->next = NULL; 即2的next置空，此时链表变为4->3->2->NULL - 返回p（4）给上一层（head=1） 步骤4：head=1的递归层 - 得到p=4（此时反转后的子链表是4->3->2） - 执行：head->next->next = head; 即1的下一个节点（2）的next指向1，也就是2->1 - 执行：head->next = NULL; 即1的next置空，此时链表变为4->3->2->1->NULL - 返回p（4）作为整个反转后链表的头节点 最终反转结果：4 → 3 → 2 → 1 → NULL 为了更直观，我们用每一步的链表状态来表示： 递归调用过程（从调用到返回）： 1. reverseList(1) 调用 reverseList(2) 2. reverseList(2) 调用 reverseList(3) 3. reverseList(3) 调用 reverseList(4) 4. reverseList(4) 返回 4 返回过程： - 从reverseList(4)返回到reverseList(3)： 在reverseList(3)中： head=3, head->next=4 p = reverseList(4)返回的4 执行：4->next = 3 (即head->next->next=head) -> 链表变为：4→3（注意，此时3的next还是4，但紧接着执行head->next=NULL，所以3的next变为NULL） 链表状态：4→3→NULL 返回p=4 - 返回到reverseList(2): head=2, head->next=3（注意，此时整个链表其实还是1->2->3->...，但在递归返回过程中，我们修改了部分指针） p=4（指向反转后子链表的头节点4） 执行：head->next->next=head 即 3->next=2 -> 链表变为：4→3→2，同时2->next原本指向3，现在执行head->next=NULL，所以2->next=NULL。 链表状态：4→3→2→NULL 返回p=4 - 返回到reverseList(1): head=1, head->next=2 p=4 执行：head->next->next=head 即2->next=1 -> 链表变为：4→3→2→1，然后1->next=NULL。 最终链表：4→3→2→1→NULL 返回p=4 由于我们无法展示动态图，建议读者在纸上画图理解每一步指针的变化。 另外，引用[5]提到了递归方法中需要注意避免形成环，所以在递归过程中及时将当前节点的next置空非常重要。 §§相关问题§§ 1. 递归反转链表的时间复杂度和空间复杂度是多少？ 2. 递归反转链表的最大深度受什么限制？ 3. 除了递归，还有哪些方法可以反转单链表？ 4. 递归反转链表在什么情况下会栈溢出？ </think> ### 递归反转单链表的动态演示（文字解释） 由于无法直接生成动画，我将通过**分步图解+代码模拟**的方式展示递归反转单链表的全过程。以链表 `1 → 2 → 3 → 4 → NULL` 为例： #### 📌 初始状态 ```mermaid graph LR A[1] --> B[2] --> C[3] --> D[4] --> E[NULL] ``` #### 🔁 递归步骤分解（参考引用[2][4][5]） 1. **递归到底层（终止条件）** - 当递归到 `head=4` 时满足终止条件（`head->next == NULL`），返回头节点 `4`： ```mermaid graph LR D[4] --> E[NULL] ``` ▶️ 返回 `p = 4` 2. **回溯到 `head=3` 的递归层** - 执行 `head->next->next = head` `4->next = 3` → 建立反向链接 - 执行 `head->next = NULL` `3->next = NULL` → 断开原链接 ```mermaid graph LR D[4] --> C[3] --> E[NULL] ``` ▶️ 返回 `p = 4`（新头节点） 3. **回溯到 `head=2` 的递归层** - `3->next = 2`（反向链接） - `2->next = NULL`（断开原链接） ```mermaid graph LR D[4] --> C[3] --> B[2] --> E[NULL] ``` ▶️ 返回 `p = 4` 4. **回溯到 `head=1` 的递归层** - `2->next = 1`（反向链接） - `1->next = NULL`（断开原链接） ```mermaid graph LR D[4] --> C[3] --> B[2] --> A[1] --> E[NULL] ``` ▶️ 返回最终头节点 `p = 4` #### 💻 递归代码模拟（C语言实现） ```c struct ListNode* reverseList(struct ListNode* head) { // 终止条件：空链表或单个节点 if (head == NULL || head->next == NULL) return head; // [^4] // 递归反转子链表（关键步骤） struct ListNode* p = reverseList(head->next); // 反转当前节点指针方向 head->next->next = head; // 后驱节点指回当前节点 [^5] head->next = NULL; // 断开原正向链接 return p; // 始终返回新链表的头节点 } ``` #### 🔑 动态过程关键点 1. **递归栈的推进方向** ```mermaid graph LR F[reverseList1] --> G[reverseList2] --> H[reverseList3] --> I[reverseList4] ``` 2. **指针反转的微观操作** - `head->next->next = head`： ```mermaid graph LR X[当前节点] --> Y[后驱节点] Y --> X ``` - `head->next = NULL`： ```mermaid graph LR X[当前节点] -->|断开| NULL ``` #### ️ 注意事项 1. 递归深度 = 链表长度，长链表可能导致**栈溢出**（引用[2]） 2. 每次递归仅处理**两个节点**的指针反转（当前节点和后驱节点） 3. 终止条件是递归正确性的关键（引用[4]） 如果需要可视化演示，推荐访问： - [Visualgo 链表反转动画](https://visualgo.net/zh/list) - [USFCA 递归可视化工具](https://www.cs.usfca.edu/~galles/visualization/Recursion.html)
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值