算法【Java】—— 递归

熵减玩家

于 2024-10-04 00:07:36 发布

阅读量431

点赞数 9

分类专栏：算法 (Java) 文章标签：算法 java

本文链接：https://blog.csdn.net/liwuqianhzc/article/details/142692380

版权

算法 (Java) 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

递归思路

首先我们要分析主问题，如果主问题可以拆分成一个又一个小问题的时候，并且这些小问题的解决方案也是一样的话，我们可以使用递归来解决。

递归函数头的设计是根据子问题的解决需要而设计的

函数体部分则是由如何解决子问题组成

最后就是递归的出口，其实就是分到不能再分的情况。

这里我们不要进行递归展开图的绘制，要相信我们的函数可以完成任务，就像相信你的编译器能进行代码的编译。

下面我们来实战演示一下：

实战演练

汉诺塔

https://leetcode.cn/problems/hanota-lcci/description/

在这里插入图片描述

太经典的题目了，这里就直接分析了，不解析题意了。

我们抽象一下，假设我们有 N 个盘子，我们需要先将 N - 1 个盘子借助 C 柱子移动到 B 柱上，然后将 A 柱上的最后一个盘子直接移动到 C 柱上，最后我们将 B 柱上的 N - 1 个盘子借助 A 柱移动到 C 柱上

那么我们的递归函数头的设计应该是盘子数量，三个柱子（初始位置，助力位置，目标位置）

递归的出口就是不能继续划分的情况也就是只有一个盘子的情况。

class Solution {
    public void move(List<Integer> A, List<Integer> B, List<Integer> C, int n) {
        if(n == 1) {
            C.add(A.remove(A.size() - 1));
            return;
        }
        move(A, C, B, n - 1);
        C.add(A.remove(A.size() - 1));
        move(B, A, C, n - 1);
    }
    public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
        int n = A.size();
        move(A, B, C, n);
    }
}

合并两个链表

https://leetcode.cn/problems/merge-two-sorted-lists/description/
在这里插入图片描述

这道题我们可以采用递归的思路来写，首先找到子问题：
在这里插入图片描述
当我们遇到两条链表的时候，我们会选取其中一个 value 值较小的作为新链表的下一个连接结点，你会发现，每次遇到两条非空链表，都是重复上面的操作，所以函数头的参数也就是两条链表。

接着就是函数体的书写，首先需要比较，然后我们思考这个函数是做什么的？很显然，这个函数需要返回一个结点，这个结点需要连接到上一个递归函数的结点后面，所以这个函数应该是返回两个链表的合适的结点。

递归的出口，当其中一条链表为空的时候，返回另一条链表即可。

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null) return list2;
        if(list2 == null) return list1;
        ListNode min = list1.val < list2.val ? list1 : list2;
        if(min == list1) 
            min.next = mergeTwoLists(list1.next, list2);
        else 
            min.next = mergeTwoLists(list1, list2.next);
        return min;
    }
}

反转链表

https://leetcode.cn/problems/reverse-linked-list/description/

在这里插入图片描述

递归的函数的作用：反转链表，返回新的头节点

函数头的设计：需要一个链表参数

函数体设计：当我们使用递归函数会得到类似下图的链表：
在这里插入图片描述

当我们得到新的头节点时，我们需要将head.next 这个结点的 next 区域的指向修改为 head, 然后我们还需要将 head 的 next 域修改为 null，为什么需要这个操作，因为最后一个结点的时候，例如上面的 1 号结点，它的next 域指向为空，为了操作的统一，所以这里统一处理为 head.next = null

递归的出口，当 head 为空或者 head 后面没有结点，这时候无需反转链表，直接返回即可。

class Solution {
    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;
    }
}

两两交换链表中的节点

https://leetcode.cn/problems/swap-nodes-in-pairs/description/

在这里插入图片描述

函数作用：返回一个交换过的链表的头节点，函数头需要一个参数也就是链表的头节点

函数体的设计：
在这里插入图片描述
head.next = 递归函数返回的头节点
r2.next = head

递归的出口：当头节点为空，或者头节点后面没有节点的时候，直接返回头节点即可

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode r2 = head.next;
        head.next = swapPairs(r2.next);
        r2.next = head;
        return r2;
    }
}

快速幂

https://leetcode.cn/problems/powx-n/

在这里插入图片描述

快速幂的方法：假设求 100 的 10 次方：
在这里插入图片描述
先求出一半的次方的幂，然后进行自我相乘，如果次方为奇数，则需要再乘一个 x

那么这个递归函数的作用就是来求出快速幂的，传参有两个， x 和 n

在进行递归之前，我们先处理一下如果次方是负数的情况，需要进行转换，由于负数最小为 2 ^ -31 ，所以转化成（int 类型）的正数的时候，会发生溢出，这里就整型提升一下。

递归的出口：n == 0 ，返回1 ，n == 1 返回自身。

class Solution {
    public double myPow(double x, int n) {
        return n < 0 ? 1 / pow(x, -(long)n) : pow(x, n);
    }

    double pow(double x, long n) {
        if(n == 0) return 1;
        if(n == 1) return x;
        double y = pow(x, n / 2);
        return n % 2 == 0 ? y * y : y * y * x;
    }
}