数据结构和算法04-单路递归

单路递归：调用一次自身

简单的递归样例

//这是伪代码，旨在展示原理
a = f(n)
n = 1;
void test(n){
    if(n > 3){
        return;
    }
    print('before'+n)
    n++;
    test(n);
    print('after'+n)
}
//行为逻辑拆分
void test(1){
    print('before'1)
    void test(2){
        print('before'2)
        void test(3){
            print('before'3)
            void test(4){
                return;
            }
            print('after'4)
        }
        print('after'3)
    }
    print('after'2)
}

案例1：阶乘

 /**
     * 阶乘
     * @return
     */
    public int factorial(int n){
        if(n == 1){
            return 1;
        }
        return n * factorial(n-1);
    }

案例2：二分查找

    /**
     * 二分查找
     * a 目标数组
     * target 目标
     * start 起始值 0
     * end  结束值 a.length
     */
    public int searchBasic(int[] a, int target,int start , int end) {
        if(start > end){
            return -1;
        }
        int m = (start+end)>>>1;
        if(target > a[m]) {
            return searchBasic(a, target, m + 1, end);
        }else if(target < a[m]){
            return searchBasic(a, target, start, end-1);
        }else{
            return a[m];
        }
    }

案例3：冒泡排序

/**
* a 初始化数组
* j 长度，默认a.length
* 其中x定义为单次排序边界，边界一侧已经排序，无需再次排序，减少循环次数
**/
public static int[] aa1(int[] a, int j) {
        if (j == 0) {
            return a;
        }
        int x = 0;
        for (int i = 0; i < j; i++) {
            if (a[i] > a[i + 1]) {
                int m = a[i];
                a[i] = a[i + 1];
                a[i + 1] = m;
                x = i;
            }
        }

        return aa1(a, x);
    }

案例4：插入排序

for (int i = 0; i < a.length-1; i++) {
            int x = a[i+1];
            for (int j = i; j >= 0; j--) {
                if(a[j] > x){
                    a[j+1] = a[j];
                    a[j] = x;
                }
            }
        }

/**
* low 初始值1
**/

public static int[] insertion(int[] a, int low) {
        if (low == a.length) {
            return a;
        }
        int t = a[low];//待插入数组 
        int i = low - 1;//右边界(i的左边认为已经排序完成) 
        while (i >= 0 && a[i] > t) {
            a[i + 1] = a[i];
            i--;
        }
        a[i + 1] = t;
        return insertion(a, low + 1);
    }