泛型递归、树的递归

最新推荐文章于 2022-11-11 11:48:27 发布
最新推荐文章于 2022-11-11 11:48:27 发布
阅读量353 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/106453541
版权

泛型递归、树的递归
视频教程：B站、网易云课堂、腾讯课堂
代码地址：Gitee、Github
存储地址：
百度云-提取码：
Google云

  1. 爬楼梯

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class Solution {
    public int climbStairs(int n) {
        if(n <= 0) return 0;
        if(n ==1 ) return 1;
        if(n ==2 ) return 2;

        int one_step_before = 2;
        int two_steps_before = 1;
        int all_ways = 0;

        for (int i = 2;i<n;i++) {
            all_ways = one_step_before +two_steps_before;
            two_steps_before = one_step_before;
            one_step_before = all_ways;

        }

        return all_ways;


    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 括号生成

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

The idea here is to only add ‘(’ and ‘)’ that we know will guarantee us a solution (instead of adding 1 too many close). Once we add a ‘(’ we will then discard it and try a ‘)’ which can only close a valid ‘(’. Each of these steps are recursively called.

java版

/*
思路：

*/

class Solution {
 public List<String> generateParenthesis(int n) {
        List<String> list = new ArrayList<String>();
        backtrack(list, "", 0, 0, n);
        return list;
    }
    
    public void backtrack(List<String> list, String str, int open, int close, int max){
        
        if(str.length() == max*2){
            list.add(str);
            return;
        }
        
        if(open < max)
            backtrack(list, str+"(", open+1, close, max);
        if(close < open)
            backtrack(list, str+")", open, close+1, max);
    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 翻转二叉树

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

public class Solution {
    public TreeNode invertTree(TreeNode root) {
        
        if (root == null) {
            return null;
        }

        final Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()) {
            final TreeNode node = queue.poll();
            final TreeNode left = node.left;
            node.left = node.right;
            node.right = left;

            if(node.left != null) {
                queue.offer(node.left);
            }
            if(node.right != null) {
                queue.offer(node.right);
            }
        }
        return root;
    }
}



/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 验证二叉搜索树

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

public class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }
    
    public boolean isValidBST(TreeNode root, long minVal, long maxVal) {
        if (root == null) return true;
        if (root.val >= maxVal || root.val <= minVal) return false;
        return isValidBST(root.left, minVal, root.val) && isValidBST(root.right, root.val, maxVal);
    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 二叉树的最大深度

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class Solution {
    public int maxDepth(TreeNode root) {
            if(root==null){
                return 0;
            }
            return 1+Math.max(maxDepth(root.left),maxDepth(root.right));
        }
}



/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 二叉树的最小深度

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/


public class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        return (left == 0 || right == 0) ? left + right + 1: Math.min(left,right) + 1;
       
    }
}

/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 二叉树的序列化与反序列化
    国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

The idea is simple: print the tree in pre-order traversal and use “X” to denote null node and split node with “,”. We can use a StringBuilder for building the string on the fly. For deserializing, we use a Queue to store the pre-order traversal and since we have “X” as null node, we know exactly how to where to end building subtress.

java版

/*
思路：

*/


public class Codec {
    private static final String spliter = ",";
    private static final String NN = "X";

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        buildString(root, sb);
        return sb.toString();
    }

    private void buildString(TreeNode node, StringBuilder sb) {
        if (node == null) {
            sb.append(NN).append(spliter);
        } else {
            sb.append(node.val).append(spliter);
            buildString(node.left, sb);
            buildString(node.right,sb);
        }
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        Deque<String> nodes = new LinkedList<>();
        nodes.addAll(Arrays.asList(data.split(spliter)));
        return buildTree(nodes);
    }
    
    private TreeNode buildTree(Deque<String> nodes) {
        String val = nodes.remove();
        if (val.equals(NN)) return null;
        else {
            TreeNode node = new TreeNode(Integer.valueOf(val));
            node.left = buildTree(nodes);
            node.right = buildTree(nodes);
            return node;
        }
    }
}

/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 二叉树的最近公共祖先
    国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q)  return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left != null && right != null)   return root;
        return left != null ? left : right;
    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 从前序与中序遍历序列构造二叉树

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

The basic idea is here:
Say we have 2 arrays, PRE and IN.
Preorder traversing implies that PRE[0] is the root node.
Then we can find this PRE[0] in IN, say it’s IN[5].
Now we know that IN[5] is root, so we know that IN[0] - IN[4] is on the left side, IN[6] to the end is on the right side.
Recursively doing this on subarrays, we can build a tree out of it 😃

java版

/*
思路：

*/

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return helper(0, 0, inorder.length - 1, preorder, inorder);
    }

    public TreeNode helper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
        if (preStart > preorder.length - 1 || inStart > inEnd) {
            return null;
        }
        TreeNode root = new TreeNode(preorder[preStart]);
        int inIndex = 0; // Index of current root in inorder
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == root.val) {
                inIndex = i;
            }
        }
        root.left = helper(preStart + 1, inStart, inIndex - 1, preorder, inorder);
        root.right = helper(preStart + inIndex - inStart + 1, inIndex + 1, inEnd, preorder, inorder);
        return root;
    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 组合

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class Solution {
  public static List<List<Integer>> combine(int n, int k) {
		List<List<Integer>> combs = new ArrayList<List<Integer>>();
		combine(combs, new ArrayList<Integer>(), 1, n, k);
		return combs;
	}
	public static void combine(List<List<Integer>> combs, List<Integer> comb, int start, int n, int k) {
		if(k==0) {
			combs.add(new ArrayList<Integer>(comb));
			return;
		}
		for(int i=start;i<=n;i++) {
			comb.add(i);
			combine(combs, comb, i+1, n, k-1);
			comb.remove(comb.size()-1);
		}
	}
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 全排列

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class Solution {
    public List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    // Arrays.sort(nums); // not necessary
    backtrack(list, new ArrayList<>(), nums);
    return list;
    }

    private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums){
    if(tempList.size() == nums.length){
        list.add(new ArrayList<>(tempList));
    } else{
        for(int i = 0; i < nums.length; i++){ 
            if(tempList.contains(nums[i])) continue; // element already exists, skip
            tempList.add(nums[i]);
            backtrack(list, tempList, nums);
            tempList.remove(tempList.size() - 1);
        }
    }
    } 
}




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

  1. 全排列 II

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

public class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(nums==null || nums.length==0) return res;
        boolean[] used = new boolean[nums.length];
        List<Integer> list = new ArrayList<Integer>();
        Arrays.sort(nums);
        dfs(nums, used, list, res);
        return res;
    }

    public void dfs(int[] nums, boolean[] used, List<Integer> list, List<List<Integer>> res){
        if(list.size()==nums.length){
            res.add(new ArrayList<Integer>(list));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i]) continue;
            if(i>0 &&nums[i-1]==nums[i] && !used[i-1]) continue;
            used[i]=true;
            list.add(nums[i]);
            dfs(nums,used,list,res);
            used[i]=false;
            list.remove(list.size()-1);
        }
    }
}



/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

一 递归的实现、特性以及思维要点

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

在这里插入图片描述

二 实战题目解析：爬楼梯、括号生成等问题

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

*Major*
关注
Java使用泛型递归构建树
T_yuqing的博客
08-22 738
定义一个树实体 @Data public class Tree<T> { /** * 节点ID */ private String id; /** * 节点的子节点 */ private List<Tree<T>> children = new ArrayList<>(); /** * 父ID */ private String parentId;
Entity Framework Code First 自身关联情况下的泛型递归实现
qq_34719168的博客
09-23 506
项目中所使用：使用EF可以将父子项全部加载进来，所以只是用递归将父子项放入list,反射加泛型使其通用。 一，实体： public class Sys_city { public Sys_city() { children = new List<Sys_city>(); } publ...
c# 泛型保存类结构，支持递归
01-07
利用c#泛型将类结构保存到XML文档，支持类嵌套
递归与泛型
三石
05-24 159
递归的本质是将一个大问题分解为一个简单的小问题然后逐步推进，比如说将1234打印出4，3，2，1的顺序，那么本质上就是n%10，可以将1234分解不断除以十，得到四个 个位数。 递归法则： 1、基准，即有穷，最终至少有一个情形是已知的，比如说第一个数或者最后一个数是可以得知的。 2、不断推进，能不断嵌套执行靠近基准。 3、递归的方法中不要做重复性的工作。 /** * @author w...
泛型与递归的概述
qq_34772386的博客
04-24 557
泛型集合: java集合框架是支持泛型的，通过设置集合的泛型实参，可以控制集合中添加的元素的数据类型，一旦创建集合对象的时候限定了泛型实参，集合中所添加的元素的类型就确定了，这样的话，把元素添加到集合里时就不再做装箱操作，获取元素时也不再做拆箱操作，避免了类型转换的异常。 泛型类: 在定义类的时候可以通过泛型形参限定类操作的数据的类，称为泛型类。 泛型通配符： ？作为泛型通配符，可以限定方法的参数
5. 泛型递归、树的递归
斜光的博客
12-22 461
树的面试题解法一般都是递归，因为 结点的定义就是以递归方式进行 重复性（自相似性） 二叉搜索树：左子树小于根节点，右子树大于根节点，且左右子树具有相同特征 1 递归（ recursion） 本质类似于循环，通过循环体进行 现实生活中的重复性 电影盗梦空间： 向下进入不同的梦境，向上回到原来的一层 通过声音同步回到上一层 每一层的内容都是一份拷贝，主角（参数）进入不同层次梦境（发生并携带变化）...
java 递归泛型_java – 递归泛型
weixin_39953673的博客
03-07 238
有没有办法使这个方法适当通用并取消警告？/*** Sort a collection by a certain "value" in its entries. This value is retrieved using* the given valueFunction which takes an entry as argument and returns* its value.** Exampl...
用递归实现C#树形结构
09-07
本篇将详细探讨如何使用递归方法来实现C#中的树形结构。 首先，理解树形结构的基本概念至关重要。在计算机科学中，树是由节点（也称为顶点）和边组成的非线性数据结构。每个节点可以有零个或多个子节点，而顶部的...
7.内部类、泛型、递归、IO、异常.md
10-30
### 内部类 #### 1. 静态内部类 静态内部类（Static Inner Class...通过以上对内部类、泛型、递归、IO和异常处理的详细解析，我们可以更深入地理解这些概念，并在实际开发中灵活运用它们来构建更健壮、更高效的程序。
泛型树遍历C#详细教程
WtfBug的博客
11-08 1018
一、前言 本篇目的 构建一个自定义泛型树Tree 定义该类的枚举器，实现先序遍历 用get访问器，实现树的中序，后序，层序遍历 开发环境 操作系统： Windows 10 X64 SDK：NET Framework 4.7.2 IDE：Visual Studio 2019 二、部分名词解释 泛型 泛型，是指通过参数化类型来实现在同一份代码上操作多种数据类型，泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。 泛型类型和普通类型的区别在于泛型类型与一组类型参数或类型变
递归泛型（recursive generic)
q__y__L的博客
11-11 480
原因很简单，SetName函数返回的对象类型是EmployeeInfoBuilder，无法调用EmployeePositionBuilder类的函数成员。当然我们可以将Employee对象以构造注入的方式传入进去，但是这样就违背了我们的Fluent原则。稍微说明一下的就是，这么做一方面是不好理解，另一方面可能对性能有一定的影响，我认为这个派生链条不宜过长，希望有懂的朋友可以指点一下。对于上面两个泛型类，我们无法直接定义，只能借助更高层次的派生类构造，且这个类不能再是泛型，也就是泛型链的终点。
java 递归泛型_递归与泛型
weixin_39663360的博客
02-27 316
递归的本质是将一个大问题分解为一个简单的小问题然后逐步推进，比如说将1234打印出4，3，2，1的顺序，那么本质上就是n%10，可以将1234分解不断除以十，得到四个 个位数。递归法则：1、基准，即有穷，最终至少有一个情形是已知的，比如说第一个数或者最后一个数是可以得知的。2、不断推进，能不断嵌套执行靠近基准。3、递归的方法中不要做重复性的工作。/*** @author wulei* 递归测试*/...
第7课-泛型递归、树的递归
hongxue8888的博客
10-21 365
文章目录递归 Recursion盗梦空间计算 n!Java 代码模版思维要点实战题目实战题目Homework 树的面试题解法一般都是递归 节点的定义 重复性(自相似性) 示例代码 def preorder(self, root): if root: self.traverse_path.append(root.val) self.preorder(root.left) ...
java 泛型 递归类型限制_递归泛型类型列表 - java
weixin_36326008的博客
03-05 192
我有一个通用接口，需要将其类型作为通用参数：interface Base> {X foo();}class Derived implements Base {public Derived foo() { ... }public Derived bar() { ... }}class Derived2 implements Base {public Derived2 foo() { ... }...
设计模式-建造者模式（具有递归类型参数的泛型类型）
weixin_63800030的博客
10-02 531
Effective-Java - 建造者模式 - 具有递归类型参数的泛型类型
Java学习之路 数据结构（一）递归、泛型复习
c72digerworld的博客
05-04 221
参考书籍：《Data Structures and Algorithm Analysis in Java》3rd — Mark Allen Weiss 动机： 在一组数据中取出特定值，这就是选择问题。选择问题的解法非常多，但能够在实践中能有效地运行下去却不多。我们必须不断改进并突破程序运行的速度、瓶颈，才能应付规模日渐庞大的数据。 基础知识复习： 递归 四条基本法则： 基准情形：必须有一个无...
java实现泛型二叉树及其各种遍历
weixin_34391854的博客
12-21 533
2019独角兽企业重金招聘Python工程师标准>>> ...
C#实现的泛型二叉树
long20804的专栏
05-04 1142
泛型二叉树 C#实现 前序 中序 后序 递归遍历
c#数据结构（1.3集合，递归，接口，泛型）
qq_40138785的博客
07-13 547
一，集合1、集合的概念      集合(Set)是由一些确定的、彼此不同的成员(Member)或者元素(Element)构成的一个整体。      成员取自一个更大的范围，称为基类型(Base Type)。集合中成员的个数称为集合的基数(Cardinality)。      例如，集合 R 由整数 3、4、5 组成，写成 R={3，4，5}。此时 R 的成员是 3、4、5，R 的基类型是整型，R ...
java递归方法用泛型
最新发布
05-05
可以使用泛型来编写递归方法，示例代码如下： ```java public class RecursiveMethod<T> { public void recursiveMethod(T value) { if (value instanceof Integer) { int intValue = (int) value; if (intValue > 0) { System.out.println(intValue); recursiveMethod(intValue - 1); } } else if (value instanceof String) { String strValue = (String) value; if (strValue.length() > 0) { System.out.println(strValue.charAt(0)); recursiveMethod(strValue.substring(1)); } } } public static void main(String[] args) { RecursiveMethod<Integer> integerRecursiveMethod = new RecursiveMethod<>(); integerRecursiveMethod.recursiveMethod(5); RecursiveMethod<String> stringRecursiveMethod = new RecursiveMethod<>(); stringRecursiveMethod.recursiveMethod("hello"); } } ``` 在上述示例中，我们定义了一个泛型类 `RecursiveMethod<T>`，并在其中定义了一个递归方法 `recursiveMethod(T value)`。该方法接受一个泛型类型的参数 `value`，并根据其类型进行不同的递归操作。在 `main` 方法中，我们分别创建了 `RecursiveMethod<Integer>` 和 `RecursiveMethod<String>` 的实例，分别传入了一个整数和一个字符串进行递归操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值