递归的执行推演过程

return的作用与意义

return 用于函数,表示不再执行其后的部分,返回调用该函数的地方继续执行。 

递归中的return,表示当前层的递归执行完毕,返回到上一层,是逐层返回的意思。(由于对return的理解不到位,很容易对递归中return产生误区)

意义

在函数中,如果碰到return 语句,那么程序就会返回调用该函数的下一条语句执行,也就是说跳出函数的执行,回到原来的地方继续执行下去。但是如果是在主函数中碰到return语句,那么整个程序就会停止,退出程序的执行。
函数的返回值是由返回语句return实现的,函数执行的最后一个操作就是返回,返回的意义是:
(1)子程序函数返回主调函数,宣告函数的一次执行结束,在调用期间所分配的变量单元被撤消;
(2)送函数值到调用表达式中,当然这一点并不是必需的,因为有些函数有返回值,有些函数没有返回值。

递归的执行推演过程

堆归求和1-100

/**
 * Copyright (C), 2000-2021, XXX有限公司
 * FileName: RecursionSum
 * Author: wangyetao
 * Date: 21-11-7 08:17:45
 * Description: 递归求和
 * <p>
 * History:
 * <author> 作者姓名
 * <time> 修改时间
 * <version> 版本号
 * <desc> 版本描述
 */
package simple.callback.recursion;

/**
 * @ClassName: RecursionSum
 * @Description: 递归求和-执行过程
 * @Author: wangyetao
 * @Date: 21-11-7 08:17:45
 */
public class RecursionSum {

    static int sum(int n, int layer) {
        //#1
        if (layer == 0) {
            System.out.println("进入主函数" + layer + "层,n=" + n);
        } else {
            System.out.println("进入递归函数第" + layer + "层,n=" + n);
        }

        //#2
        if (n <= 1) {
            System.out.println("n <= 1;return n;");
            return n;
        }

        //#3
        layer++;
        //#4
        int sum = n + sum(n - 1, layer);
        //#5
        if ((layer - 1) == 0) {
            System.out.println("返回主函数第" + (layer - 1) + "层,n=" + n + ",sum=" + sum);
        } else {
            System.out.println("返回递归函数第" + (layer - 1) + "层,n=" + n + ",sum=" + sum);
        }

        //#6
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(sum(100, 0));
    }

}

执行过程

进入主函数0层,n=100
进入递归函数第1层,n=99
进入递归函数第2层,n=98
进入递归函数第3层,n=97
进入递归函数第4层,n=96
进入递归函数第5层,n=95
进入递归函数第6层,n=94
进入递归函数第7层,n=93
进入递归函数第8层,n=92
进入递归函数第9层,n=91
进入递归函数第10层,n=90
进入递归函数第11层,n=89
进入递归函数第12层,n=88
进入递归函数第13层,n=87
进入递归函数第14层,n=86
进入递归函数第15层,n=85
进入递归函数第16层,n=84
进入递归函数第17层,n=83
进入递归函数第18层,n=82
进入递归函数第19层,n=81
进入递归函数第20层,n=80
进入递归函数第21层,n=79
进入递归函数第22层,n=78
进入递归函数第23层,n=77
进入递归函数第24层,n=76
进入递归函数第25层,n=75
进入递归函数第26层,n=74
进入递归函数第27层,n=73
进入递归函数第28层,n=72
进入递归函数第29层,n=71
进入递归函数第30层,n=70
进入递归函数第31层,n=69
进入递归函数第32层,n=68
进入递归函数第33层,n=67
进入递归函数第34层,n=66
进入递归函数第35层,n=65
进入递归函数第36层,n=64
进入递归函数第37层,n=63
进入递归函数第38层,n=62
进入递归函数第39层,n=61
进入递归函数第40层,n=60
进入递归函数第41层,n=59
进入递归函数第42层,n=58
进入递归函数第43层,n=57
进入递归函数第44层,n=56
进入递归函数第45层,n=55
进入递归函数第46层,n=54
进入递归函数第47层,n=53
进入递归函数第48层,n=52
进入递归函数第49层,n=51
进入递归函数第50层,n=50
进入递归函数第51层,n=49
进入递归函数第52层,n=48
进入递归函数第53层,n=47
进入递归函数第54层,n=46
进入递归函数第55层,n=45
进入递归函数第56层,n=44
进入递归函数第57层,n=43
进入递归函数第58层,n=42
进入递归函数第59层,n=41
进入递归函数第60层,n=40
进入递归函数第61层,n=39
进入递归函数第62层,n=38
进入递归函数第63层,n=37
进入递归函数第64层,n=36
进入递归函数第65层,n=35
进入递归函数第66层,n=34
进入递归函数第67层,n=33
进入递归函数第68层,n=32
进入递归函数第69层,n=31
进入递归函数第70层,n=30
进入递归函数第71层,n=29
进入递归函数第72层,n=28
进入递归函数第73层,n=27
进入递归函数第74层,n=26
进入递归函数第75层,n=25
进入递归函数第76层,n=24
进入递归函数第77层,n=23
进入递归函数第78层,n=22
进入递归函数第79层,n=21
进入递归函数第80层,n=20
进入递归函数第81层,n=19
进入递归函数第82层,n=18
进入递归函数第83层,n=17
进入递归函数第84层,n=16
进入递归函数第85层,n=15
进入递归函数第86层,n=14
进入递归函数第87层,n=13
进入递归函数第88层,n=12
进入递归函数第89层,n=11
进入递归函数第90层,n=10
进入递归函数第91层,n=9
进入递归函数第92层,n=8
进入递归函数第93层,n=7
进入递归函数第94层,n=6
进入递归函数第95层,n=5
进入递归函数第96层,n=4
进入递归函数第97层,n=3
进入递归函数第98层,n=2
进入递归函数第99层,n=1
n <= 1;return n;
返回递归函数第98层,n=2,sum=3
返回递归函数第97层,n=3,sum=6
返回递归函数第96层,n=4,sum=10
返回递归函数第95层,n=5,sum=15
返回递归函数第94层,n=6,sum=21
返回递归函数第93层,n=7,sum=28
返回递归函数第92层,n=8,sum=36
返回递归函数第91层,n=9,sum=45
返回递归函数第90层,n=10,sum=55
返回递归函数第89层,n=11,sum=66
返回递归函数第88层,n=12,sum=78
返回递归函数第87层,n=13,sum=91
返回递归函数第86层,n=14,sum=105
返回递归函数第85层,n=15,sum=120
返回递归函数第84层,n=16,sum=136
返回递归函数第83层,n=17,sum=153
返回递归函数第82层,n=18,sum=171
返回递归函数第81层,n=19,sum=190
返回递归函数第80层,n=20,sum=210
返回递归函数第79层,n=21,sum=231
返回递归函数第78层,n=22,sum=253
返回递归函数第77层,n=23,sum=276
返回递归函数第76层,n=24,sum=300
返回递归函数第75层,n=25,sum=325
返回递归函数第74层,n=26,sum=351
返回递归函数第73层,n=27,sum=378
返回递归函数第72层,n=28,sum=406
返回递归函数第71层,n=29,sum=435
返回递归函数第70层,n=30,sum=465
返回递归函数第69层,n=31,sum=496
返回递归函数第68层,n=32,sum=528
返回递归函数第67层,n=33,sum=561
返回递归函数第66层,n=34,sum=595
返回递归函数第65层,n=35,sum=630
返回递归函数第64层,n=36,sum=666
返回递归函数第63层,n=37,sum=703
返回递归函数第62层,n=38,sum=741
返回递归函数第61层,n=39,sum=780
返回递归函数第60层,n=40,sum=820
返回递归函数第59层,n=41,sum=861
返回递归函数第58层,n=42,sum=903
返回递归函数第57层,n=43,sum=946
返回递归函数第56层,n=44,sum=990
返回递归函数第55层,n=45,sum=1035
返回递归函数第54层,n=46,sum=1081
返回递归函数第53层,n=47,sum=1128
返回递归函数第52层,n=48,sum=1176
返回递归函数第51层,n=49,sum=1225
返回递归函数第50层,n=50,sum=1275
返回递归函数第49层,n=51,sum=1326
返回递归函数第48层,n=52,sum=1378
返回递归函数第47层,n=53,sum=1431
返回递归函数第46层,n=54,sum=1485
返回递归函数第45层,n=55,sum=1540
返回递归函数第44层,n=56,sum=1596
返回递归函数第43层,n=57,sum=1653
返回递归函数第42层,n=58,sum=1711
返回递归函数第41层,n=59,sum=1770
返回递归函数第40层,n=60,sum=1830
返回递归函数第39层,n=61,sum=1891
返回递归函数第38层,n=62,sum=1953
返回递归函数第37层,n=63,sum=2016
返回递归函数第36层,n=64,sum=2080
返回递归函数第35层,n=65,sum=2145
返回递归函数第34层,n=66,sum=2211
返回递归函数第33层,n=67,sum=2278
返回递归函数第32层,n=68,sum=2346
返回递归函数第31层,n=69,sum=2415
返回递归函数第30层,n=70,sum=2485
返回递归函数第29层,n=71,sum=2556
返回递归函数第28层,n=72,sum=2628
返回递归函数第27层,n=73,sum=2701
返回递归函数第26层,n=74,sum=2775
返回递归函数第25层,n=75,sum=2850
返回递归函数第24层,n=76,sum=2926
返回递归函数第23层,n=77,sum=3003
返回递归函数第22层,n=78,sum=3081
返回递归函数第21层,n=79,sum=3160
返回递归函数第20层,n=80,sum=3240
返回递归函数第19层,n=81,sum=3321
返回递归函数第18层,n=82,sum=3403
返回递归函数第17层,n=83,sum=3486
返回递归函数第16层,n=84,sum=3570
返回递归函数第15层,n=85,sum=3655
返回递归函数第14层,n=86,sum=3741
返回递归函数第13层,n=87,sum=3828
返回递归函数第12层,n=88,sum=3916
返回递归函数第11层,n=89,sum=4005
返回递归函数第10层,n=90,sum=4095
返回递归函数第9层,n=91,sum=4186
返回递归函数第8层,n=92,sum=4278
返回递归函数第7层,n=93,sum=4371
返回递归函数第6层,n=94,sum=4465
返回递归函数第5层,n=95,sum=4560
返回递归函数第4层,n=96,sum=4656
返回递归函数第3层,n=97,sum=4753
返回递归函数第2层,n=98,sum=4851
返回递归函数第1层,n=99,sum=4950
返回主函数第0层,n=100,sum=5050
5050

Process finished with exit code 0
<think>嗯,用户现在想了解链表反转的递归方法。让我先回忆一下链表反转的基本概念。链表反转是一个常见的算法问题,通常可以用迭代或者递归两种方法来解决。用户可能已经了解迭代的方法,现在想深入理解递归的实现。 首先,我需要确认链表的结构。通常单链表节点包含一个值和一个指向下一个节点的指针。递归的关键在于找到基准情况和递归步骤。反转链表的递归方法可能需要从链表的末尾开始,逐步反转每个节点的指针方向。 接下来,我得想清楚递归的基准情况。当链表为空或者只有一个节点时,反转后的链表就是它本身,所以基准情况应该是当节点为空或者节点的下一个节点为空时返回当前节点。这时候递归开始回溯,逐个调整指针。 然后,递归步骤应该如何处理呢?假设从第n个节点开始递归,当递归到最后一个节点时,返回该节点作为新的头节点。然后每一层递归需要将当前节点的下一个节点的next指针指向自己,同时将自己的next指针置为null,避免形成环。这一步可能需要画图来辅助理解,确保指针的正确调整。 用户可能对递归的过程感到困惑,特别是如何通过递归调用来改变指针的指向。需要详细解释每一层递归的作用,以及如何将问题分解为更小的子问题。例如,假设链表为1->2->3->4->null,递归到最后一个节点4时,返回4作为新头节点。然后回到3的递归层,将4的next指向3,同时3的next原本指向4,现在需要置为null,避免循环。依次类推,直到处理完整个链表。 还需要注意边界条件的处理,比如空链表或者只有一个节点的链表,这时候直接返回即可。同时,要确保在反转后,原来的头节点变成了尾节点,其next指针为null。 可能用户在实际编写代码时会遇到问题,比如忘记将当前节点的next置为null,导致链表出现环。这时候需要强调每一步指针调整的重要性。此外,递归的栈深度问题也需要提及,如果链表过长可能导致栈溢出,这时候迭代方法可能更优。 总结来说,递归反转链表的关键在于基准条件的确定和递归步骤中指针的调整。通过将大问题分解为小问题,逐步从后往前调整指针方向,最终实现整个链表的反转。需要确保用户理解递归的调用顺序和指针变化的每一步,这样才能正确实现算法。</think>链表反转的递归实现可通过分解问题与反向链接实现,以下是逐步解析: --- ### **一、基础定义** - **链表节点结构** ```java class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } ``` - **递归核心思想** 将链表分为 **头节点** 与 **剩余部分**,递归反转剩余链表后,调整指针方向。 --- ### **二、递归步骤拆解** 1. **基准条件** ```java if (head == null || head.next == null) return head; ``` - 空链表或单节点链表无需反转 2. **递归调用** ```java ListNode newHead = reverseList(head.next); // 假设后续链表已反转 ``` 3. **反向链接** ```java head.next.next = head; // 将下一节点的next指向当前节点 head.next = null; // 断开原正向链接 ``` --- ### **三、执行过程演示(以1->2->3->4为例)** | 递归层级 | 操作分解 | 链表状态变化 | |----------|-------------------------------|-----------------------| | 初始状态 | `1 -> 2 -> 3 -> 4 -> null` | | | 递归至末节点 | `newHead`指向4 | `4 -> null` | | 回溯到节点3 | 设置`3.next.next = 3` | `4 -> 3`,`3.next=null` | | 回溯到节点2 | 设置`2.next.next = 2` | `4 -> 3 -> 2`,`2.next=null` | | 回溯到节点1 | 设置`1.next.next = 1` | `4 -> 3 -> 2 -> 1`,`1.next=null` | --- ### **四、代码实现** ```java public ListNode reverseList(ListNode head) { if (head == null || head.next == null) return head; ListNode newHead = reverseList(head.next); head.next.next = head; // 关键反向操作 head.next = null; // 防止循环 return newHead; } ``` --- ### **五、复杂度分析** - **时间复杂度**:$O(n)$,每个节点访问一次 - **空间复杂度**:$O(n)$,递归栈深度与链表长度成正比 --- ### **六、递归 vs 迭代对比** | | 递归实现 | 迭代实现 | |----------|------------------------|------------------------| | 代码简洁性 | ⭐⭐⭐⭐ | ⭐⭐⭐ | | 空间复杂度 | $O(n)$(栈空间) | $O(1)$ | | 适用场景 | 短链表/教学演示 | 长链表/生产环境 | --- 通过递归的逐层回溯完成指针反向,需重点理解 **“当前节点后续链表已反转”** 的假设前提。建议结合图示逐步推演指针变化过程
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

dnbug Blog

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

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

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

打赏作者

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

抵扣说明:

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

余额充值