java排序算法

低效排序

冒泡排序

//冒泡排序：前一个元素和后一个元素进行对比；稳定排序
public class Bubble {
    public static void sort(Comparable[] a){
        for (int i = 0; i <a.length-1 ; i++) {
            for (int j = i+1; j <a.length ; j++) {
                //比较索引i和索引j的值
                if(greater(a[i],a[j])){
                    exch(a,i,j);
                }
            }
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array={1,5,7,2,3,9,213,5403,540,539};
        Bubble.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

插入排序

//：分为已排序，和未排序；默认第一个为已排序:稳定排序
public class Inserton {
    public static void sort(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0 ; j--) {
                if(greater(a[j-1],a[j])){
                    exch(a,j-1,j);
                }else{
                    break;
                }
            }
            ArrayList<Object> objects = new ArrayList<>();
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    public static void main(String[] args) {
        Integer[] array={1,5,7,2,3,9,213,5403,540,539};
        Inserton.sort(array);
        System.out.println(Arrays.toString(array));
    }

选择排序

//用最小索引值进行比较 :不稳定排序
public class Selection {
    public static void sort(Comparable[] a){
        for (int i = 0; i < a.length-1; i++) {
            //最小索引
            int minIndex=i;
            for (int j = i+1; j < a.length; j++) {
                //用最小索引值进行比较
                if(greater(a[minIndex],a[j])){
                    minIndex=j;
                }
            }
            exch(a,i,minIndex);
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
public class Test {
    public static void main(String[] args) {
        Integer[] array={1,5,7,2,3,9,213,5403,540,539};

        Selection.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

高效排序

希尔排序

//进行元素分组：如增长量5、2、1 不稳定排序
public static void sort(Comparable[] a){
        //1.根据数组a的长度 确定增长量h的初始值
        int h=1;
        while (h<a.length/2){
            //增长量公式
            h=2*h+1;
        }
        while (h>=1){
            //排序
            //2.1找到待插入的元素
            for (int i = h; i <a.length ; i++) {
                //2.2把待插入的元素插入到有序数据中
                for (int j = i; j >=h ; j-=h) {
                    //待插入的元素a[j];比较a[j]和a[j-h]
                    if(greater(a[j-h],a[j])){
                        //交换元素
                        exch(a,j-h,j);
                    }else {
                        //待插入元素已经找到了合适的位置！结束循环！
                        break;
                    }

                }
            }

            //减小h的值
            h=h/2;
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    public class Test {
    public static void main(String[] args) {
        Integer[] array={1,5,7,2,3,9,213,5403,540,539};

        Shell.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

归并排序

//稳定排序
public class Merge {
    //归并所需要的辅助数组
    private static Comparable[] assist;


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



    /**
     * 比较v元素是否小于w元素
     * @param v
     * @param w
     * @return
     */
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

    /**
     * 数组元素i和j交换位置
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    /**
     * 对数组a中从lo到hi的索引位置元素进行排序
     * @param a
     * @param lo
     * @param hi
     */
    public 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+1到hi索引为一组；对着两组数据进行归并
     * @param a
     * @param lo
     * @param mid
     * @param hi
     */
    public static void merge(Comparable[] a,int lo,int mid,int hi){
        //定义三个指针
        int i=lo;
        int p1=lo;
        int p2=mid+1;
        //遍历，移动p1指针和p2指针，比较对应索引出的值，找出小的那个放到辅助数组索引指针i中
        while (p1<=mid && p2<=hi){
            //比较对应索引处的值
            if(less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else{
                assist[i++]=a[p2++];
            }
        }
        //如果p1的指针没有走完，nana那么顺序移动p1指针，把对应的元素方法辅助数组的对应索引处
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        //如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素方法辅助数组的对应索引处
        while (p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助元素的数组元素拷贝到原数组中
        for (int index=lo;index<=hi;index++) {
            a[index]=assist[index];
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array={1,5,7,2,3,9,213,5403,540,539};

        Merge.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

快速排序

public class Quick {

    public static void sort(Comparable[] a){
        int lo=0;
        int hi=a.length-1;
        sort(a,lo,hi);
    }



    /**
     * 比较v元素是否小于w元素
     * @param v
     * @param w
     * @return
     */
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

    /**
     * 数组元素i和j交换位置
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    /**
     * 对数组a中从lo到hi的索引位置元素进行排序
     * @param a
     * @param lo
     * @param hi
     */
    public static void sort(Comparable[] a,int lo,int hi){
        //做安全校验
        if(hi<=lo){
            return;
        }
        int partition = partition(a, lo, hi);//返回的是分组分界值所在的索引，是分界值变换后的索引
        //对lo到hi之间的数据进行分为两个组(左子组和右子组)
        //让左子组有序
        sort(a,lo,partition-1);
        //让右子组有序
        sort(a,partition+1,hi);
    }

    /**
     * 对数组中，从lo到hi索引之间的元素进行分组,并返回分组界限对应的索引
     * @param a
     * @param lo
     * @param hi
     */
    public static int partition(Comparable[] a,int lo,int hi){
        //确定分界值
        Comparable key=a[lo];
        //定义两个指针，分别指向待切分元素的最小索引处和做大索引处的下一个位置
        int left=lo;
        int right=hi+1;
        //切分
        while (true){
            //先从右往左扫描，移动right指针，找到一个比分界值小的元素，停止
            while (less(key,a[--right])){
                if(right==lo){
                    break;
                }
            }
            //再从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
            while (less(a[++left],key)){
                if(left==hi){
                    break;
                }
            }
            //判断left>=right；如果是 则证明元素扫描完毕；结束循环，如果不是，则交换元素即可
            if(left>=right){
                break;
            }else{
                exch(a,left,right);
            }
        }
        //交换分界值
        exch(a,lo,right);
        return right;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array={1,5,7,2,3,9,213,5403,540,539};

        Quick.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

递归排序

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

    /**
     * 如2=1*2
     * 3：1*2*3
     * 4:1*2*3*4
     * 5:1*2*3*4*5
     * @param n
     * @return
     */
    public static long factorial(int n){
        if(n==1){
            return 1;
        }
        return n*factorial(n-1);
    }
}