递归是自己调用自己,java里的递归写法如下:
 
/**
  * 1*2*(n-1)*n的计算形式,使用递归实现
  * @author Administrator
  *
  */
 public class DiGui {
 //初始化变量,不能使用默认值
 private static long result = 1;
 
 /**
 * 非递归方式
 * @param n
 * @return
 */
 private static long notDiGui(int n) {
 for(int i = 1; i <= n; i++) {
 result = result * i;
 }
 return result;
 }
 
 /**
 * 递归
 * @param n
 * @return
 */
 private static long diGui(int n) {
 if(n == 1) {
 return 1;
 }
 return diGui(n - 1) * n;
 }
 
 public static void main(String[] args) {
 long num$1 = DiGui.notDiGui(9);
 long num$2 = DiGui.diGui(9);
 System.out.println(num$1 + " " + num$2);
 }
 }
 

 
 
  
1.首先我们得有一个树状结构的表，类似这种结构。必须得有 id，pid  其他的根据需要来。

 
 
  
我们叫它treeTbl表吧。这里pid为0的表示是顶级节点。
 
  
 
 
  
 
 
  
2.接着select * from treeTbl ，并将得到的list 转换成一个Map集合，
 
  
   key 为 pid ，value 为 子元素对象集合或者子元素id集合之类的都可以，根据需要。
 
  
   我这里只需要id，所以是定义为了List<string>类型。
 
  
  
 
  
		Map<String,List<String>> map=new HashMap<String,List<String>>();
		for(Object[] obj : list)
		{
			String id=obj[0].toString();
			String pid=obj[1].toString();
			if(map!=null && map.get(pid)!=null){
				map.get(pid).add(dic_id);
			}else{
				List<String> list_tmp=new ArrayList<String>();
				list_tmp.add(id);
				map.put(pid,list_tmp);
			}
		}
 
  
 
 
  
 
 
  
3.递归遍历，说明在注释中
 
  
 
 
  
	
	        //最终得到的子孙集合
		List<String> idList=new ArrayList<String>();
		
		/*
		  这个pid的值根据需要来，
		  如果要获取整棵树，这里就填根节点的id，treeTbl表中的根节点的 id 为 0
		  如果是获取指定父级节点下的所有子孙节点，就填该父节点的 id 值
		 */
		List<String> chidrenList=map.get(pid);
		
		/*
		   上面得到的chidrenList仅仅是底下一层的节点集合，也就是说只包含了子节点，未包含子节点下的所有子孙节点
		   如果变量pid表示第一层的话，这里我们从第二层开始递归
		   也就是不停的寻找下一层下一层下一层……直到不存在下一层为止
		   如何判断有无下一层呢，之前创建好的HashMap已存好父子关系，用它来判断就好

		*/
		for(String id : childrenList){
			//用于递归的方法，只有把 id 下的所有子孙节点全部存入idList，才会进行下一轮循环
			getChildrens(map, id ,idList);
		}
		
		//将之前第一层子节点也加入进来(这个地方根据需要来)
		idList.addAll(chidrenList);
 
  
 
 
  
 
 
  
 
 
  
  
 
  
	 private void getChildrens(Map<String,List<String>> map,String id,List<String> idList)
	 {
		//查询当前id下的子级的集合
		List<String> list=map.get(id);
		
		//如果list不为空，则表示该id下还有子id，重新调用当前方法进行递归查询
		if(list!=null && list.size()>0){
			for(String id2 : list){
				//存入集合
				idList.add(id2);
				//再查一次
				getChildrens(map, id2, idList);
			}
		}
		
	 }
 
  
 
 
  
 
 
  
 
 
  
 
 
 
 
 
 
  
大小: 6.1 KB
  
查看图片附件
 
 
转载于:https://www.cnblogs.com/xcxcxcxc/p/5541142.html

public class SwapNode2 {
    public static ListNode swapNode(ListNode head){
        if(head == null || head.next == null){
            return head;
        }
        ListNode firstNode = head;
        ListNode secondNode = head.next;

        firstNode.next = swapNode(secondNode.next);
        secondNode.next = firstNode;

        return secondNode;
    }

    public static void main(String[] args){
        ListNode head = new ListNode(1);
        ListNode node1 = new ListNode(2);
        ListNode node2 = new ListNode(3);
        ListNode node3 = new ListNode(4);
        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        head = swapNode(head);
        ListNode temp = head;
        while (temp != null){
            System.out.println(temp.val);
            temp = temp.next;
        }
    }
}
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
 
 

第一种普通写法
 

 
 

public class Demo {

    public static void main(String[] args) {
        int num1 = 1;
        int num2 = 1;
        int num3 = 0;
        System.out.println(num1);
        System.out.println(num2);
        for (int i = 1; i < 10; i++) {  
            num3 = num1 + num2;
            num1 = num2;                                                                                                                  
            num2 = num3;
            System.out.println(num3);
        }
    }                     
}


 第二种数组形式递归的写法
 

 
 

public class DIGUI1 {
 
    public static void main(String[] args) {
        int  []arr=new int[20];
         arr[1]=1;
         arr[2]=1;
         System.out.print(" "+arr[1]);
          System.out.print(" "+arr[2]);
        for(int i=3;i<20;i++){
             arr[i]=arr[i-1]+arr[i-2];
            System.out.print("   "+arr[i]);
        }
    }
 }


 第三种 递归形式的写法
 

 

public class Demo {


    public static int f(int n) throws Exception {
        if(n==0){
           throw new Exception("参数错误！");
        }
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return f(n-1)+f(n-2);//自己调用自己
        }
 }


    public static void main(String[] args) throws Exception {
        for (int i = 1; i <=10; i++) {
            System.out.print(f(i)+" ");
        }
    }  
}
 

 
 
用递归最大的问题就是效率问题了，但是有的程序必须用递归写才可以写出来。例如著名的汉若塔问题，如果有谁可以用其他方式写出来我服。