递归每次自己调用自己，每次调用自己后函数的数据会较上次缩减，而且最后缩减至无需继续递归。内层函数调用完成，外层函数才算调用完成

  n的阶乘伪代码

外层必须逐级向里面递，最后再向外归。

public class 递归_02 {
    public static void main(String[] args) {
        String s =new Scanner(System.in).next(); //链式编程
       f(s,0);

    }
    public static  void f(String s,int n){
       if (n==s.length()){
            return;//到字符串结尾的下一个结束，然后返回
    }
       f(s,n+1); //执行他的下一个内容，
        System.out.print(s.charAt(n));
    }
}

递归用来解决二分问题 

public class 递归_二分查找 {
    public static void main(String[] args) {
   int arr[]={1,2,3,4,5};
        System.out.println(f(arr,5,0, arr.length-1));
    }
    public  static  int f(int []a ,int target,int i,int j){
        if (i>j){
            return -1; //结束的条件
        }
        int mid=(i+j)>>1;
        
        if (target<a[mid]){
            return f(a,target,i,mid-1);
        } else if (target>a[mid]) {
            return f(a,target,mid+1,j);

        }else {
            return mid;
        }
    }
}

递归实现冒泡排序

public class 递归_冒泡排序 {
    public static void main(String[] args) {
      int [] arr={1,5,2,4,9,10,14,11};
        System.out.println(Arrays.toString(arr));
      bubble(arr,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    //
    public static void bubble(int [] a,int j){
         if (j==0){
             //到了第一个元素，就剩下一个元素了，不用进行排序
             return;
         }
         int x=0; //
        for (int i = 0; i < j; i++) { //不能等于j，因为有一个i+1;
            if (a[i]>a[i+1]){ //交换变量需要找一个中间量，tempt
                int tempt=a[i];
                a[i]=a[i+1];
                a[i+1]=tempt;
                x=i;
            }
            //还要进行递归排序
            bubble(a,x);  //引入x优化算法
            

            //优化算法内容
        }
    }
}