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;
            }
        }