leetcode---递归

最新推荐文章于 2022-09-28 21:55:33 发布
最新推荐文章于 2022-09-28 21:55:33 发布
阅读量185 收藏
点赞数
分类专栏： leetcode刷题记 文章标签： leetcode recursion
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccnuacmhdu/article/details/102772329
版权

1137. 第 N 个泰波那契数

在这里插入图片描述

【代码一】超时

class Solution {
    public int tribonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1 || n == 2){
            return 1;
        }
        return tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3);
    }
}

【代码二】通过—动态规划

class Solution {
    public int tribonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1 || n == 2){
            return 1;
        }
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = dp[2] = 1;
        for(int i = 3; i <= n; i++){
            dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
        }
        return dp[n];
    }
}

【代码三】通过—记忆搜索

class Solution {
    private int[] dp; // 记忆数组
    public int tribonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1 || n == 2){
            return 1;
        }
        dp = new int[n+1];
        dp[0] = 0;
        dp[1] = dp[2] = 1;
        for(int i = 3; i <= n; i++){
            dp[i] = -1;
        }
        return solve(n);
    }
    private int solve(int n){
        if(dp[n] == -1){
            dp[n] = solve(n-1) + solve(n-2) + solve(n-3);
        }
        return dp[n];
    }
}

【代码四】通过—三个变量直接递推

class Solution {
    public int tribonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1 || n == 2){
            return 1;
        }
        // 直接用三个变量递推，类似于动态规划，但不记录中间结果
        int a = 0;
        int b = 1;
        int c = 1;
        int tmp;
        for(int i = 3; i <= n; i++){
            tmp = a + b + c;
            a = b;
            b = c;
            c = tmp;
        }
        return c;
    }
}

【代码五】通过—直接打表（利用题目数据范围）

class Solution {
    private int[] table = {
	    0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136, 5768, 10609, 19513, 35890, 66012, 121415,223317, 410744, 755476, 1389537, 2555757, 4700770, 8646064, 15902591, 29249425, 53798080, 98950096, 181997601,334745777, 615693474, 1132436852, 2082876103};

    public int tribonacci(int n) {
        return table[n];
    }
}

938. 二叉搜索树的范围和

在这里插入图片描述
【代码一】通过—二叉搜索树遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int rangeSumBST(TreeNode root, int L, int R) {
        if(root == null){
            return 0;
        }
        if(root.val < L){
            return rangeSumBST(root.right, L, R);
        }
        if(root.val > R){
            return rangeSumBST(root.left, L, R);
        }
        return rangeSumBST(root.left, L, R) + rangeSumBST(root.right, L, R) + root.val;
    }
}

【代码二】通过—普通二叉树遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int rangeSumBST(TreeNode root, int L, int R) {
        if(root == null){
            return 0;
        }
        if(root.val < L || root.val > R){
            return rangeSumBST(root.right, L, R) + rangeSumBST(root.left, L, R);
        }
        return rangeSumBST(root.left, L, R) + rangeSumBST(root.right, L, R) + root.val;
    }
}

894. 所有可能的满二叉树

在这里插入图片描述在这里插入图片描述在这里插入图片描述
【代码一】通过—暴力递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<TreeNode> allPossibleFBT(int N) {
        /**
            确定是什么问题重要。。整棵树是”满二叉树“，以每个节点为根的子树也是”满二叉树“，
            这就是递归了。。
            节点总数是N，首先N必定是奇数，递归结束条件易定，N为偶数或N=1。递归拆解子问题
            FBT(N) = {x >= 1 && x < N, 递归左子树FBT(x)，递归右子树FBT(N-1-x)，1->根 
        */
        List<TreeNode> ans = new ArrayList<>();
        
        if(N == 1){
            ans.add(new TreeNode(0));
            return ans;
        }
        if(N % 2 == 0){
            return ans;
        }
        
        for(int x = 1; x < N; x += 2){
            List<TreeNode> leftT = allPossibleFBT(x);
            List<TreeNode> rightT = allPossibleFBT(N-1-x);
            for(TreeNode l : leftT){
                for(TreeNode r : rightT){
                    TreeNode root = new TreeNode(0);
                    root.left = l;
                    root.right = r;
                    ans.add(root);
                }
            }
        }
        return ans;
    }
}

【代码二】通过—记忆化搜索

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    
    private Map<Integer, List<TreeNode> > map = new HashMap<>();
    
    public List<TreeNode> allPossibleFBT(int N) {
        /**
            确定是什么问题重要。。整棵树是”满二叉树“，以每个节点为根的子树也是”满二叉树“，
            这就是递归了。。
            节点总数是N，首先N必定是奇数，递归结束条件易定，N为偶数或N=1。递归拆解子问题
            FBT(N) = {x >= 1 && x < N, 递归左子树FBT(x)，递归右子树FBT(N-1-x)，1->根 
        */
        
        if(map.containsKey(N)){
            return map.get(N);
        }
        
        List<TreeNode> ans = new ArrayList<>();
        
        if(N == 1){
            ans.add(new TreeNode(0));
            return ans;
        }
        if(N % 2 == 0){
            return ans;
        }
        
        for(int x = 1; x < N; x += 2){
            List<TreeNode> leftT = allPossibleFBT(x);
            List<TreeNode> rightT = allPossibleFBT(N-1-x);
            for(TreeNode l : leftT){
                for(TreeNode r : rightT){
                    TreeNode root = new TreeNode(0);
                    root.left = l;
                    root.right = r;
                    ans.add(root);
                }
            }
        }
        map.put(N, ans);
        return ans;
    }
}

783. 二叉搜索树结点最小距离

在这里插入图片描述在这里插入图片描述
【代码一】通过—欠妥暴力思路
遍历出来，搞成一个数组，排序，遍历一遍比较搞定。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private List<Integer> list = new ArrayList<>();
    public int minDiffInBST(TreeNode root) {
        dfs(root);
        Collections.sort(list, new Comparator<Integer>(){
           public int compare(Integer x, Integer y){
               return x - y;
           } 
        });
        int min = Integer.MAX_VALUE;
        for(int i = 1; i < list.size(); i++){
            if(list.get(i) - list.get(i-1) < min){
                min = list.get(i) - list.get(i-1);
            }
        }
        return min;
    }
    private void dfs(TreeNode root){
        if(root != null){
            list.add(root.val);
            dfs(root.left);
            dfs(root.right);
        }
    }
}

【代码二】通过—利用二叉搜索树性质，边遍历边比较

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private TreeNode pre = null;
    private int min = Integer.MAX_VALUE;
        
    public int minDiffInBST(TreeNode root) {
        dfs(root);
        return min;
    }
    private void dfs(TreeNode root){
        if(root != null){
            dfs(root.left);
            if(pre != null){
                min = min > root.val - pre.val ? root.val - pre.val : min;
            }
            pre = root;
            dfs(root.right);
        }
    }
}

779. 第K个语法符号

在这里插入图片描述在这里插入图片描述

【代码一】超时—暴力递归

class Solution {
    public int kthGrammar(int N, int K) {
        String s = f(N);
        return s.charAt(K-1) - '0';
    }
    private String f(int N){
        if(N == 1){
            return "0";
        }
        String s = f(N-1);
        String obj = "";
        for(int i = 0; i < s.length(); i++){
            obj += s.charAt(i) == '0' ? "01" : "10";
        }
        return obj;
    }
}

【代码二】通过—找规律

class Solution {
    public int kthGrammar(int N, int K) {
        // 与其说递归，不如说是找规律。。
        // 第N行前一半和第N-1行完全一样。
        // 第N行后一半和第N-1行完全相反。
        if(N == 1){
            return 0;
        }
        int len = (1 << (N-2)); // 第N行长度
        if(K <= len){
            return kthGrammar(N-1, K);
        }
        return 1 - kthGrammar(N-1, K-len); // 0转成1，1转成0
    }
}

【代码三】通过—借助二叉树

class Solution {
    public int kthGrammar(int N, int K) {
        // 看成是二叉树
        // 0的左孩子是0，右孩子是1。1与之相反。K的奇偶可定左孩子还是右孩子
        // 关键问题就是找父亲是1还是0，递归往上走。
        // 树的每层都是从1开始数
        // K为偶数时，kthGrammar(N, K)的父亲是kthGrammar(N, K/2)
        // K为奇数时，kthGrammar(N, K)的父亲是kthGrammar(N, (K+1)/2)
        if(N == 1){
            return 0;
        }
        if(K % 2 == 0){
            return 1 - kthGrammar(N-1, K/2);
        }else{
            return kthGrammar(N-1, (K+1)/2);
        }
    }
}

698. 划分为k个相等的子集

在这里插入图片描述
【代码一】通过—暴力回溯

class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        // 回溯法。
        // 先对数组求和得sum及最大值max,
        // 1.若sum%k != 0 || max > sum/k（此max无法放入任一个桶），返回false
        // 2.搞成K个桶，每个桶初始值都是0，尝试每个数依次放入不同桶中，如果所有桶
        //   都能达到sum/k，就返回true。尝试所有情况都不行，那就返回false
        
        int sum = 0;
        int max = 0; // 因为nums[i]>0
        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
            max = max < nums[i] ? nums[i] : max;
        }
        if(sum % k != 0 || max > sum/k){
            return false;
        }
        int[] bucket = new int[k];
        Arrays.fill(bucket, 0);
        return backtrack(nums, k, bucket, sum/k, 0);
    }
    // cur ---> 尝试放当前值nums[cur]放入某个桶
    private boolean backtrack(int[] nums, int K, int[] bucket, int avg, int cur){
        if(cur >= nums.length){ // 已经尝试放完了所有的值到K个桶中
            return true;
        }
        for(int i = 0; i < K; i++){
            // 某值nums[cur]满足啥标准才放入桶bucket[i]中，这是关键
            if(bucket[i] + nums[cur] <= avg){
                bucket[i] += nums[cur]; // TODO，若需记录实际每个桶中有哪些值，可以在这里记录
                // dfs，直至搜出一条路，或不满足回退
                if(backtrack(nums, K, bucket, avg, cur+1)){
                    return true;
                }else{
                    bucket[i] -= nums[cur];
                }
            }
        }
        // 已经尝试所有情况，都没有返回true，说明没有解
        return false;
    }
}

687. 最长同值路径

在这里插入图片描述在这里插入图片描述
【代码一】通过—二叉树递归遍历
参考资料链接

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private int ans;
    
    public int longestUnivaluePath(TreeNode root) {
        ans = 0;
        len(root);
        return ans;
    }
    // 记录以某个节点作为根，包含根的左右单侧最长路径
    private int len(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = len(root.left);
        int right = len(root.right);
        int leftL = 0, rightL = 0;
        if(root.left != null && root.val == root.left.val){
            leftL = left + 1;
        }
        if(root.right != null && root.val == root.right.val){
            rightL = right + 1;
        }
        ans = Math.max(ans, leftL + rightL);
        return Math.max(leftL, rightL);
    }
}
Only you, only you!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode——递归
weixin_40906441的博客
03-18 124
1.区别 1）程序结构不同 递归是重复调用 函数自身 实现循环。 迭代是函数内某段代码实现循环。 其中，迭代与普通循环的区别是：迭代时，循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值。 2）算法结束方式不同 递归循环中，遇到满足终止条件的情况时 逐层返回 来结束。 迭代则根据语句条件判断是否 直接结束循环。 2.递归 一个大问题是否可分解为子问题 子问题的解决方法是否和大问题相同 找到终止条件 ...
LeetCode 递归教程
02-28
LeetCode 英文版 递归的教程，只把非会员的部分摘录了下来，没有会员不对。
Leetcode-递归
qq_49723651的博客
02-07 576
文章目录q21 合并两个有序链表q101 对称二叉树q104 二叉树的最大深度q226 翻转二叉树q236 二叉树的最近公共祖先 q21 合并两个有序链表 题目传送门 题解 可以使用递归和迭代两种方法进行求解，两种方法都比较简单。 递归： func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode { if l1 == nil { return l2 } else if l2 == nil { return l1 } else if
leetcode - 递归
mike_jun的博客
03-15 494
目录 98.验证搜索二叉树 22.括号生成 100.相同的树 101.对称二叉树 104.树的最大深度 108.将有序数组转换成搜索二叉树 110.平衡二叉树 111.二叉树的最小深度 112.路径总和 226.翻转二叉树 98.验证搜索二叉树 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 ...
LeetCode之递归算法
ZHOUJIAN_TANK的博客
07-23 294
递归三步曲 何为递归？程序反复调用自身即是递归。 我自己在刚开始解决递归问题的时候，总是去纠结这一层函数做了什么，它调用自身后的下一层函数又做了什么。。。。然后就会觉得实现一个递归解法十分复杂，根本就无法下手。 这是一个思维误区，一定要走出来，既然递归是一个反复调用自身的过程，这就是说它的每一及的功能都是一样的，因此我们只需要关注一级递归的解决过程即可 如上图所示，我们需要关心的主要是以下三点 整个递归的终止条件 一级递归需要做什么 应该返回给上一级的返回值是什么 因此，也就有了我们解递归题的三步
leetcode-java
03-21
leetcode-java 课程1：Java入门与基础算法 Fizz Buzz-> Java语言 字符串和数组 类和对象 参考 界面 数据结构： 链表 栈 阴离子 树 哈希表 算法： 枚举 递归 分治 排序 在IDE里打印输出，并输出分行-> System.out....
LeetCode-Hot-100
03-25
《LeetCode-Hot-100》是针对程序员面试中热门的100道LeetCode题目集合，主要涉及C++编程语言。LeetCode是一个在线平台，提供了一系列算法问题，旨在帮助开发者提升编程技能，尤其是面试准备阶段。这些题目涵盖了数据...
《leetcode-solutions》
04-19
5. 递归与迭代：递归是许多算法的基础，如二分查找、深度优先搜索等，而迭代则常见于循环结构和状态更新。 6. 编程语言实现：尽管LeetCode支持多种编程语言，但大部分解决方案都可能包括了Java、Python、C++等主流...
Leetcode-Solutions:解决leetcode问题
03-19
1. 动态规划：动态规划是一种优化的递归方法，通过存储子问题的解来避免重复计算，广泛应用于最优化问题，如背包问题、最长公共子序列等。 2. 回溯法：适用于寻找所有可能解的问题，如八皇后问题、N皇后问题、组合...
Leetcode-Submissions
03-22
4. **代码效率**：C++代码是如何实现高效运行的，比如通过减少不必要的遍历、使用迭代而非递归等方式。 5. **错误处理**：在处理边界条件和异常情况时，代码是如何进行错误检查和预防的。 6. **代码风格**：良好的...
leetcode算法-递归
Prayer96的博客
03-22 160
递归 函数直接或间接地调用自己。 生活中的例子 从前有座山的故事。 从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事：从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事：。。。 4个要素 接受的参数 返回值 递归终止条件 递归拆解：如何递归到下一层 斐波拉契数列 0，1，1，2，3，5，8… f(n) = f(n - 1) + f(n - 2)，其中f(0) = 0，f(1) = 1 recursion(int n) { if(n < 2) return
LeetCode刷题：递归
weixin_38370441的博客
03-26 147
递归例题439. 三元表达式解析器21. 合并两个有序链表779. 第K个语法符号 递归与回溯的不同： 递归是能够确定唯一解，向着一个方向不断深入 回溯则是有不同的决策，每一步都需要试探，需要根据状态决定是否回滚。 例题 439. 三元表达式解析器 https://leetcode-cn.com/problems/ternary-expression-parser/ Key point： T的话取3-最后一个：之间的数据 F的话取最后一个：之后的数据 21. 合并两个有序链表 https://leetc
leetcode之递归详解
ahelloyou的博客
06-24 407
递归 其实递归和二叉树遍历很像,要理解递归,就要理解二叉树遍历. 可以看看这个理解一下 首先说明一个问题，简单阐述一下递归，分治算法，动态规划，贪心算法这几个东西的区别和联系，心里有个印象就好。 递归这种尽量能不用就不用,有时候会造成过大的额外开销以及栈溢出,可以根据这个思想选用贪心算法,动态规划,bfs,dfs等 递归是一种编程技巧，一种解决问题的思维方式；分治算法和动态规划很大程度上是递归思想基础上的（虽然动态规划的最终版本大都不是递归了，但解题思想离不开递归），解决更具体问题的两类算法思想；贪心算法是
LeetCode专题----递归
changetocs的博客
12-24 938
1、111. Minimum Depth of Binary Tree Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. 分析：在
LeetCode——树：递归
努力努力再努力L
02-15 352
LeetCode——树：递归 目录 概述 树的高度（LeetCode104） 平衡树（LeetCode110） 两节点的最长路径（LeetCode543） 翻转树（LeetCode226） 归并两棵树（LeetCode617） 判断路径和是否等于一个数（LeetCode112） 统计路径和等于一个数的路径数量（LeetCode437） 子树（LeetCode572） 树的对称（LeetCode...
LeetCode 刷题 -- 递归
最新发布
qq_43325216的博客
09-28 1099
在上述代码的递归调用里，调用的是f(n-1)和f(n-2)，但是在f(n-1)的递归里面，f(n-2)其实已经计算过了，但是后面还会重复计算。如果最后一步走1个台阶，那么就是n=n-1时候的方法，如果最后一步走2个台阶，那么就是n=n-2的方法，因此 f(n)=f(n-1)+f(n-2)3、如果只有一个节点为null，这种是需要调换左右节点的，假设左节点不为null，右节点为null，那么调换之后，左节点为null，右节点不为null，因此可以不需要特殊处理。）同时，这个节点的子节点也要进行相同的操作。
《Leetcode零基础刷题指南》- 递归
YQ20210216的博客
02-17 455
目录 前言 一、递归基本介绍 二、阶乘后的0（传送门） 三、完全二叉树的节点个数（传送门） 总结 前言 一、递归基本介绍 递归只要记住三点内容: 1）你要实现一个函数，这个函数会自己调用自己，并且每次调用，函数传参是不一样的; 2)递归一定要有出口，即满足一定条件后需要return，否则就可能出现死递归（引起栈溢出); 3）根据递推式来补充你的递归调用内容; 二、阶乘后的0（传送门） 给定一个整数 n ，返回 n! 结果中尾随零的数量。 提示n...
leetcode高频题笔记之递归
clonechen
03-21 430
文章目录括号生成验证二叉搜索树二叉树的最大高度二叉树的最小深度翻转二叉树二叉搜索树的最近公共祖先二叉树的最近公共祖先从前序与中序遍历序列构造二叉树 括号生成 dfs深度搜索 public class Main { List<String>res; public List<String> generateParenthesis(int n) { ...
【LeetCode】 70. 爬楼梯--简单递归的应用
小码农养成记
10-15 335
简单递归 C++ 通过找规律发现后面数字等于前面两项之和 于是通过简单递归写出程序如下 #include &amp;lt;iostream&amp;gt; using namespace std; int ds(int n){ if(n==0) return 0; else if (n==1) return 1; else if(n==2) return 2; else return ds(...
理解递归：LeetCode 递归基础教程
"LeetCode 递归教程是一个关于计算机科学中的递归概念的教程，主要摘录了非会员部分的内容，未包含会员专享部分。这个教程适用于已经学习过二叉树和栈基础知识的学习者，旨在帮助初学者理解递归的概念、如何解决递归...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值