递归调用

Posted 2021-10-20 Ferocious

1.menu实体类

package com.dafy.insureagent.bean;
 
public class Menu {
    private String id;  
    private String name;  
    private String pid;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    @Override
    public String toString() {
        return "Menu [id=" + id + ", name=" + name + ", pid=" + pid + "]";
    }  
    
}

2.测试类

package com.dafy.insureagent.bean;
 
import java.util.ArrayList;
import java.util.List;
 
public class MenuRecursion {
    //子节点
    static List<Menu> childMenu = new ArrayList<Menu>();
 
    /**
     * 获取某个父节点下面的所有子节点
     * @param menuList
     * @param pid
     * @return
     */
    public static List<Menu> treeMenuList(List<Menu> menuList, int pid) {
        for (Menu mu : menuList) {
            //遍历出父id等于参数的id，add进子节点集合
            if (Integer.valueOf(mu.getPid()) == pid) {
                //递归遍历下一级
                treeMenuList(menuList, Integer.valueOf(mu.getId()));
                childMenu.add(mu);
            }
        }
        return childMenu;
    }
    
    
 
    public static void main(String args[]) {
        List<Menu> menuList = new ArrayList<Menu>();
        Menu mu = new Menu();
        mu.setId("1");
        mu.setName("目录");
        mu.setPid("0");
        Menu mu1 = new Menu();
        mu1.setId("2");
        mu1.setName("目录1");
        mu1.setPid("1");
        Menu mu2 = new Menu();
        mu2.setId("3");
        mu2.setName("目录1.1");
        mu2.setPid("2");
        Menu mu3 = new Menu();
        mu3.setId("4");
        mu3.setName("目录1.2");
        mu3.setPid("2");
        Menu mu4 = new Menu();
        mu4.setId("5");
        mu4.setName("目录2");
        mu4.setPid("1");
        Menu mu5 = new Menu();
        mu5.setId("6");
        mu5.setName("目录2.1");
        mu5.setPid("5");
        Menu mu6 = new Menu();
        mu6.setId("7");
        mu6.setName("目录2.2");
        mu6.setPid("5");
        Menu mu7 = new Menu();
        mu7.setId("8");
        mu7.setName("目录2.2.1");
        mu7.setPid("7");
        menuList.add(mu);
        menuList.add(mu1);
        menuList.add(mu2);
        menuList.add(mu3);
        menuList.add(mu4);
        menuList.add(mu5);
        menuList.add(mu6);
        menuList.add(mu7);
 
        List<Menu> childList = treeMenuList(menuList, 1);
        for (Menu m : childList) {
            System.out.println(m.getId() + "   " + m.getName());
        }
    }
 
}

3.控制台结果(注:本身节点不会获取)：

3   目录1.1
4   目录1.2
2   目录1
6   目录2.1
8   目录2.2.1
7   目录2.2
5   目录2

4.在项目中的应用

/**
     * 递归获取某个父机构节点下面的所有子机构节点
     * @param childOrg 要返回的结果
     * @param orgList  数据库查询出来的所有机构集合
     * @param pid      父id
     * 注:本身的机构节点不会添加进去
     */
    private void orgRecursion(List<OrganizationVo> childOrg,List<OrganizationVo> orgList, int pid) {
        for (OrganizationVo org : orgList) {
            if (org.getParentId() != null) {
                //遍历出父id等于参数的id，add进子节点集合
                if (org.getParentId() == pid) {
                    //递归遍历下一级
                    orgRecursion(childOrg,orgList, org.getId());
                    //末级机构才添加进去(依自己业务定义)
                    if (org.getOrgLevel() == 3) {
                        childOrg.add(org);
                    }
                }
            }
        }
    }

二.递归总结

1.何为递归：个人理解就是自己调用自己，直到满足一个条件结束自己调用自己的过程，这个就是递归。

2.注意：递归肯定要有一个出口，不然就死循环了。

3.注意：递归方法不要嵌业务逻辑，尽量只要获取递归结果就行

三.常见递归算法

1）最常见的就是阶乘，比如求5的阶乘，数学公式就是：54321，代码：

public class Digui {
    public static int digui(int n){
        if(n==1||n==0){
            return n;
        }else{
            System.out.println("执行第" + n + "次");
            return n*digui(n-1);
        }
    }
public static void main (String[] args){
    System.out.print(digui(5));
}

2）求1+2+3+4+5+6+7……+1000的和

    static int  count(int n){
        if(n>0){
            return n+count(n-1);
        }else{
            return 0;
        }
 
    }
 
    public static void main(String args[])
    {
        int sum=count(1000);
        System.out.println(sum);
    }
}

3）1,1,2,3,5,8,13,21,34...，求用递归算第30个数

    static int count(int n){
        if(n==1||n==2) {
            return 1;
        }
         return count(n-1)+count(n-2);
    }
 
    public static void main(String args[])
    {
        int sum=count(30);
        System.out.println(sum);
    }

转载自：https://blog.csdn.net/u010825931/article/details/79925719

递归调用后的代码递归

【中文标题】递归调用后的代码递归

【英文标题】：Recursion with code after the recursive call

【发布时间】：2018-08-13 17:46:40

【问题描述】：

我试图了解递归是如何工作的，但还有一件事我不太明白：当递归函数本身内的递归调用之后有代码时，递归函数是如何工作的.请参阅下面的示例伪代码以帮助了解我的意思。 我的确切问题是递归调用之后的代码将以什么顺序（意味着何时）执行。 机器会注意递归调用，在调用之后执行剩余的代码位（打印“完成”），然后返回并实际执行整个递归调用，或者机器将在到达该行时立即执行递归调用，并且仅在该递归底部之后执行最后一段代码（打印“完成”） out？ 什么时候“完成”会被打印多少次？

void recurse()

  print "hello world";
  for i = 0 up to 2
    recurse();

  print "done";

【问题讨论】：

当有递归调用时，编译器等不会对代码执行顺序的正常规则做出任何异常。事情的运行顺序与 recurse() 完全是其他函数一样。

那么这意味着什么时候和多少次“完成”将被打印？请帮助我理解这一点！我是递归新手！

由于本例中的递归是无限的，因此“完成”never 被打印出来。 （可能不是你想要的。）

@usercow 您是否尝试过使用任何语言？您的函数没有终止条件，这意味着它永远不会停止。对recurse() 的每次调用都会再调用两次，因此它打印"hello world" 的次数将呈指数增长，理论上是无限的。实际上，它最终会在"done"出现之前耗尽堆栈空间并崩溃。

【参考方案1】：

递归调用在它下面的任何代码之前运行。一旦它返回，它将返回并完成其余的代码。那么会发生什么

"hello world"
i = 0
"hello world"
i = 0
"hello world"
...

永远。因为您没有将i 的值传递给下一个递归函数，所以您的代码将永远运行，每次都以i=0 重新启动。

假设您确实将i 正确传递给了递归函数：

void recurse(i) 
    // is i still < 2?
    if (i < 2) 
        print "hello world";
        recurse(i+1);
        print "done";
    

recurse(0);

在这种情况下，你会得到：

i = 0
"hello world"
    i = 1
    "hello world"
        i = 2
    "done"
"done" 

【参考方案2】：

可视化递归的一个好方法是使用堆栈的深度/高度。您可能知道，每当调用一个新函数时，它都会像煎饼一样被推入堆栈，将深度/高度增加 1。如果您对其进行编码并打印带有缩进的“开始”和“结束”注释以可视化深度，应该很容易看出什么时候执行的。如果不清楚，时间在 Y 轴上（上面打印的内容在下面的内容之前执行），递归深度在 X 轴上。

这是 Python 中的代码：

def recurse(depth=0):
    if depth < 4:
        print("    " * depth + f"starting at depth depth")

        for _ in range(2):
            recurse(depth + 1)

        print("    " * depth + f"ending at depth depth")

recurse()

输出：

starting at depth 0
    starting at depth 1
        starting at depth 2
            starting at depth 3
            ending at depth 3
            starting at depth 3
            ending at depth 3
        ending at depth 2
        starting at depth 2
            starting at depth 3
            ending at depth 3
            starting at depth 3
            ending at depth 3
        ending at depth 2
    ending at depth 1
    starting at depth 1
        starting at depth 2
            starting at depth 3
            ending at depth 3
            starting at depth 3
            ending at depth 3
        ending at depth 2
        starting at depth 2
            starting at depth 3
            ending at depth 3
            starting at depth 3
            ending at depth 3
        ending at depth 2
    ending at depth 1
ending at depth 0

可以看出，循环中产生了两个相同的递归调用。通过循环的第一次行程在第二次开始之前完成其整个递归执行。两个递归调用完成后，整个调用结束。

另请注意，深度表示没有子节点的base case 或终端/叶节点。您的原始算法将无限递归并炸毁堆栈。