基本排序算法

主函数

public class sort_Algorithm {
    public static void main(String[] args) {
        int array[]={8,4,8,2,0,21,54,11,98,1,43,23,193,45,67,94,27,49,51,121,9,3,16,235,77,48,13,35,154,99,28,88};
        System.out.println(example.isSort(array));
        //new Selection(array);
        //new Insertion(array);
        //new Shell(array);
        //Merge.sort(array);
        //Base.baseSort(array);
        Quick.sort(array);
        System.out.println(example.isSort(array));
        for (int i = 0; i <array.length; i++) {
             System.out.print("\t"+array[i]);
        }
    }
}

辅助函数，进行对比，换位等操作（因为这是刚接触数据结构写的，Java还不熟练，就练习了特性，特地试了一下内部类，不习惯可以改一下）

public class example {
    public example(){}
    public static boolean isSort(int[] a) {
        for (int i = 1; i <a.length ; i++) {
            if(a[i]<a[i-1]){return false;}
        }
        return true;
    }
    public static boolean less(int a, int b){
        return (a<b);
    }

    public static class exchange {
        public exchange(int[] a, int i, int j) {
            int temp=0;
            temp=a[i];
            a[i]=a[j];
            a[j]=temp;
        }
    }
}

桶排序，基数排序：先找到最大数，然后数其位数，利用位数进行低位到高位的依次排序，中间利用计数排序

import java.util.Arrays;

public class Base {
    public static int large(int[]a){
        int large=a[0];
        for(int i=1;i<a.length;i++){
            if(large<a[i]){
                large=a[i];
            }
        }
        return large;
    }
    public static int pow(int large){
        int N=1;
        if(large==0)return 0;
        while(large%10!=0||large==10){
            large=large/10;
            N++;
        }
        return N;
    }
    public static void baseSort(int[]array){
        int[] count=new int[10];
        int[]result=new int[array.length];
        int maxDegree=pow(large(array));
        for(int i=0;i<maxDegree;i++){
            int division= (int) Math.pow(10,i);
            for(int j=0;j<array.length;j++){
                int num=array[j]/division%10;
                count[num]+=1;
                System.out.println(num+"-----"+count[num]);
            }
            //计数排序
            for(int m=1;m<count.length;m++){
                count[m]+=count[m-1];
                System.out.println(m+"$$$$$"+count[m]);
            }
            for(int n=array.length-1;n>=0;n--){
                int numb=array[n]/division%10;
                result[--count[numb]]=array[n];
                System.out.println(numb+"??????"+count[numb]);
            }
            System.arraycopy(result,0,array,0,array.length);
            Arrays.fill(count,0);
        }
    }
}

插入排序

public class Insertion {
    public Insertion(){}
    public Insertion(int []a){
        for (int i = 1; i <a.length ; i++) {
            for (int j =i; j >0&&new example().less(a[j],a[j-1]) ; j--) {
                new example.exchange(a,j,j-1);
            }
        }
    }
}

归并排序

​

public class Merge {
    private static int[] aux;
    public static void merge(int[] a,int low,int mid,int hi){
        int i=low,j=mid+1;
        for(int k=low;k<=hi;k++){
            aux[k]=a[k];
        }
        for(int k=low;k<=hi;k++){
            if(i>mid) a[k]=aux[j++];
            else if(j>hi) a[k]=aux[i++];
            else if(example.less(aux[i],aux[j])) a[k]=aux[i++];
            else a[k]=aux[j++];
        }
    }

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

    private static void sort(int[] a, int low, int hi) {
        if(hi<=low) return;
        int mid=(hi-low)/2+low;
        sort(a,low,mid);
        sort(a,mid+1,hi);
        merge(a,low,mid,hi);
    }
}

[点击并拖拽以移动]
​

 快速排序

public class Quick {
    public static void sort(int[]array){
        sort(array,0,array.length-1);
    }

    private static void sort(int[] array, int low, int hi) {
        if(low>=hi) return;
        int j=partition(array,low,hi);
        sort(array,low,j-1);
        sort(array,j+1,hi);
    }

    private static int partition(int[] array, int low, int hi) {
        int mid=array[low];
        int i=low,j=hi+1;
        while (true){
            while (example.less(array[++i],mid)) if(i==hi) break;
            while (example.less(mid,array[--j])) if(j==low) break;
            if(i>=j) break;
            new example.exchange(array,i,j);
        }
        new example.exchange(array,low,j);
        return j;
    }
}

选择排序

public class Selection {
    public Selection(){}

    public Selection(int[] a) {
            int temp=a[0],rem=0;
            for (int i = 0; i < a.length; i++) {
                for (int j =i+1; j <a.length ; j++) {
                    if(new example().less(a[j],a[i])){ new example.exchange(a,i,j);}
                }
            }
    }

}

希尔排序

public class Shell {

    public Shell(int []a){
        int h=1;
        example ex=new example();
        while(h<a.length/3){h=3*h+1;}
        while(h>=1){
            for (int i =h; i <a.length; i++) {
                for (int j =i; j>=h&&ex.less(a[j],a[j-h]); j-=h) {
                    new example.exchange(a,j,j-h);
                }
            }
            h=h/3;
        }
    }
}

下图是几种排序的比较