java 递归在实例中的几种用途(ps:准确获取树的子节点)

  递归做为一种算法程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说,递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时,递归前进;当边界条件满足时,递归返回(递归简单说就是程序调用自身的编程技巧,前面说这么多废话只是为了显得专业一点)

  先看一个简单求阶乘的例子:
        public long factorial(long i){//求i
           if(i==0)return 1;  
           else return i*factorial(i-1);//利用递归i!=n*(i-1)!直到0
        }

例子一汉诺塔(经典例子)
      public class super1{
         static int count=1;
           public static void move(char j,char k){
              System.out.println("第"+(super1.count++)+"步:把一个杯子从桌子"+j+"拿到杯子"+k);
           }
           public static void hanoi(char a,char b,char c,int n){
          if(n==1)move(a,c);
           else{hanoi(a,c,b,n-1);
              move(a,c);
              hanoi(b,a,c,n-1);
           }
        }
       public static void main(String[] args){
           char a=‘A‘,b=‘B‘,c=‘C‘;
           int num=3;//杯子的个数
           hanoi(a,b,c,num);
        }
    }
  输出如下:
         第1步:把一个盘子从桌子A拿到桌子C
      第2步:把一个盘子从桌子A拿到桌子B
      第3步:把一个盘子从桌子C拿到桌子B
      第4步:把一个盘子从桌子A拿到桌子C
      第5步:把一个盘子从桌子B拿到桌子A
      第6步:把一个盘子从桌子B拿到桌子C
      第7步:把一个盘子从桌子A拿到桌子C

例子二Java 树父节点递归获取树子节点
         之前做项目遇到树无法定位准确的子节点就是看这个例子解决的,自己重新写了一遍这个例子代码如下:

类一:
          package com.kd;
          
          import java.util.ArrayList;
          import java.util.Iterator;
          import java.util.List;
          
          
          /**
           * 获取子节点
           */
          public class Super2 {
              
              private List<Long> returnList = new ArrayList<Long>();
              
              /**
               * 根据父节点的ID获取所有子节点
               * @param list 分类表
               * @param typeId 传入的父节点ID
               * @return String
               */
              public String getChildNodes(List<Node> list, Long typeId) {
                  if(list == null && typeId == null) return "";
                  for (Iterator<Node> iterator = list.iterator(); iterator.hasNext();) {
                      Node node = (Node) iterator.next();
                      // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
                      if (node.getParentId()==0 && typeId==node.getId()) {
                          recursionFn(list, node);
                      }
                      // 二、遍历所有的父节点下的所有子节点
                      /*if (node.getParentId()==0) {
                          recursionFn(list, node);
                      }*/
                  }
                  return returnList.toString();
              }
              
              private void recursionFn(List<Node> list, Node node) {
                  List<Node> childList = getChildList(list, node);// 得到子节点列表
                  if (hasChild(list, node)) {// 判断是否有子节点
                      returnList.add(node.getId());
                      Iterator<Node> it = childList.iterator();
                      while (it.hasNext()) {
                          Node n = (Node) it.next();
                          recursionFn(list, n);
                      }
                  } else {
                      returnList.add(node.getId());
                  }
              }
              
              // 得到子节点列表
              private List<Node> getChildList(List<Node> list, Node node) {
                  List<Node> nodeList = new ArrayList<Node>();
                  Iterator<Node> it = list.iterator();
                  while (it.hasNext()) {
                      Node n = (Node) it.next();
                      if (n.getParentId() == node.getId()) {
                          nodeList.add(n);
                      }
                  }
                  return nodeList;
              }
          
              // 判断是否有子节点
              private boolean hasChild(List<Node> list, Node node) {
                  return getChildList(list, node).size() > 0 ? true : false;
              }
              
              
              // 本地模拟数据测试
              public static void main(String[] args) {
                  long start = System.currentTimeMillis();
                  List<Node> nodeList = new ArrayList<Node>();
                  Node node1 = new Node(1l, "蔬菜", 0l);
                  Node node2 = new Node(2l, "水产", 0l);
                  Node node3 = new Node(3l, "畜牧", 0l);
                  Node node4 = new Node(4l, "瓜类", 1l);
                  Node node5 = new Node(5l, "叶类", 1l);
                  Node node6 = new Node(6l, "丝瓜", 4l);
                  Node node7 = new Node(7l, "黄瓜", 4l);
                  Node node8 = new Node(8l, "白菜", 1l);
                  Node node9 = new Node(9l, "虾", 2l);
                  Node node10 = new Node(10l, "鱼", 2l);
                  Node node11 = new Node(11l, "牛", 3l);
                  
                  nodeList.add(node1);
                  nodeList.add(node2);
                  nodeList.add(node3);
                  nodeList.add(node4);
                  nodeList.add(node5);
                  nodeList.add(node6);
                  nodeList.add(node7);
                  nodeList.add(node8);
                  nodeList.add(node9);
                  nodeList.add(node10);
                  nodeList.add(node11);
                  
                  Super2 mt = new Super2();
                  System.out.println(mt.getChildNodes(nodeList, 1l));
                  long end = System.currentTimeMillis();
                  System.out.println("用时:" + (end - start) + "ms");
              }
           }
类二:
        package com.kd;
        /**
         * 无限级节点模型
         */
        public class Node {
            /**
             * 节点id
             */
            private Long id;
        
            /**
             * 节点名称
             */
            private String nodeName;
        
            /**
             * 父节点id
             */
            private Long parentId;
        
            public Node() {
            }
            Node(Long id, Long parentId) {
                this.id = id;
                this.parentId = parentId;
            }
            Node(Long id, String nodeName, Long parentId) {
                this.id = id;
                this.nodeName = nodeName;
                this.parentId = parentId;
            }
            public Long getId() {
                return id;
            }
        
            public void setId(Long id) {
                this.id = id;
            }
        
            public Long getParentId() {
                return parentId;
            }
        
            public void setParentId(Long parentId) {
                this.parentId = parentId;
            }
            public String getNodeName() {
                return nodeName;
            }
            public void setNodeName(String nodeName) {
                this.nodeName = nodeName;
            }
        }

时间: 2024-10-12 12:44:15

java 递归在实例中的几种用途(ps:准确获取树的子节点)的相关文章

Java递归调用实例

private int num=0; private String parentCode = null; private String returnCode = null; /** * 查询顶级外场,如果当前部门的上级部门一直是外场,那就返回最顶层的orgcode,如果一直不是外场,就返回最初的orgcode, * 如果中间有一个是外场,并且它的父级部门不是外场,就返回是外场的部门code..然后根据returnCode查找这个部门下的所有部门 * sql中主要使用where--contact-

Java中弹出对话框中的几种方式

1.显示一个错误对话框,该对话框显示的 message 为 'alert': JOptionPane.showMessageDialog(null, "alert", "alert", JOptionPane.ERROR_MESSAGE); 2.显示一个内部信息对话框,其 message 为 'information': JOptionPane.showInternalMessageDialog(frame, "information",&quo

Android基础入门教程——8.1.2 Android中的13种Drawable小结 Part 2

Android基础入门教程--8.1.2 Android中的13种Drawable小结 Part 2 标签(空格分隔): Android基础入门教程 本节引言: 本节我们继续来学习Android中的Drawable资源,上一节我们学习了: ColorDrawable:NinePatchDrawable: ShapeDrawable:GradientDrawable!这四个Drawable~ 而本节我们继续来学习接下来的五个Drawable,他们分别是: BitmapDrawable:Insert

递归获取当前节点全部指定类型的子节点

在线预览 方法 使用nodeType判断类型,在allChildNodes方法内建立递归函数将allCN封装在方法内. <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> <style> p{ color: red; } span{ color: blue; }

Java开发中的23种设计模式详解(转)

设计模式(Design Patterns) --可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样.项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周

MVC模式在Java Web应用程序中的实例分析

MVC作为软件架构中及其重要的一种架构思想,在实际的java web项目开发中被开发者们广泛的应用.遵循MVC思想的所产生的解决方法也可以因实际情况的不同来进行不同的选择.这里以一个应用struts+hibernate+jsp的实例来进一步认识MVC. 学生管理系统中添加学生模块的的MVC架构: Model(系统的业务逻辑):Hibernate进行管理的数据实体+定义的业务逻辑的体现--------数据库操作类,也就是通常所说的Dao层 数据实体(PO,Entity): package PO;

0. Java开发中的23种设计模式详解(转)

设计模式(Design Patterns) ——可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样.项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周

【js实例】js中的5种基本数据类型和9种操作符

js中的5中基本数据类型 js标识符 第一个字符必须为字母,下划线,或美元符 其他字符可以是字母,下划线,美元符,数字 js标识符区分大小写 标识符不能使关键字和保留字 关键字: break do instanceof typeof case else new var catch finally return void continue for switch while debugger function this with default if throw   delete in try  

Java开发中的23种设计模式

一.设计模式的分类 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 其实还有两类:并发型模式和线程池模式.用一个图片来整体描述一下: 二.设计模式的六大原则 1.开闭原则(Open Clo