递归调用

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