递归排序算法

递归

• 简单递归求n的阶乘

public class FactorialTest {

    public static void main(String[] args) {
        long result = factorial(5);
        System.out.println(result);
    }

    public static long factorial(int n){
        if(n==1){
            return 1;
        }
        return n*factorial(n-1);
/*        while (n>1){  
            return n*factorial(n-1);
        }
        return 1;*/
    }
}

归并排序

原理

• 排序原理：
  1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
  2. 将相邻的两个子组进行合并成一个有序的大组；
  3. 不断的重复步骤2，直到最终只有一个组为止。
     
     

API设计

代码

package paixu;

/**
 * @ClassName Merge
 * @Authoc 孙少聪
 * @Date 2022/7/24 09:20:15
 */

public class Merge {
    private static Comparable[] assist;

    public static void sort(Comparable[] a){
        // 初始化辅助数组assist
        assist = new Comparable[a.length];
        // 定义一个lo变量，和hi变量记录数据中组中最小索引和最大索引
        int lo = 0;
        int hi = a.length-1;
        // 调用sort重载方法完成数组a中，从索引hi的元素排序
        sort(a,lo,hi);
    }

    /*对数组内从lo到hi的元素进行排序*/
    private static void sort(Comparable[] a,int lo,int hi){
        // 安全性校验
        if(hi <= lo){
            return;
        }
        // 对数据lo和hi之间的数据进行分为两个组
        int mid = lo+(hi-lo)/2;
        // 分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);
    }

    /*对数组中从lo到mid为一组，从mid到hi为一组，对这两组数据进行归并*/
    private static void merge(Comparable[] a,int lo,int mid,int hi){
        // 定义三个指针
        int i = lo;
        int p1 = lo;
        int p2 = mid+1;
        // 遍历，移动p1指针和p2指针，遍历比较对应的指针指向的数据大小，放到对应的辅助数组中对应位置就可以了
        while (p1<=mid && p2<=hi){
            // 比较对应索引处的值
            if(less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++] = a[p2++];
            }
        }
        // 遍历，如果p1没有走完，那么顺序移动p1指针，把对应元素放到辅助数组对应的索引位置
        while (p1<=mid){
            assist[i++] = a[p1++];
        }
        // 遍历，如果p2没有走完，那么顺序移动p2指针，把对应元素放到辅助数组对应的索引位置
        while (p2<=hi){
            assist[i++] = a[p2++];
        }
        // 把辅助数组中的元素放在数组中
        for (int j = lo; j <= hi; j++) {
            a[j] = assist[j];
        }
    }

    private static Boolean less(Comparable a,Comparable b){
        return a.compareTo(b) < 0;
    }

    private static void exch(Comparable[] o,int a,int b){
        Comparable temp;
        temp = o[a];
        o[a] = o[b];
        o[b] = temp;
    }
}

• 测试

    public static void main(String[] args) {
        Integer[] o = {10,9,8,7,6,5,4,3,2,1,90};
        Merge.sort(o);
        System.out.println(Arrays.toString(o));
    }

效率对比

• 以10000-1完全倒序为例子进行希尔排序和归并排序进行比较
• 归并排序
  
• 希尔排序
  
• 希尔排序和归并排序效率其实差不多，只是使用场合不同，归并排序是典型的空间换时间的排序方式