数据结构与算法（排序）

 

 

/**
插入排序
*/
public class Insertion {
    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;
                }
            }
        }
    }
    private static boolean greater(Comparable v,Comparable w){
        return  v.compareTo(w)>0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

/**
希尔排序
*/
 22:29:25
public class Xier {
    public static void sort(Comparable[] a){
        for (int h=a.length/2;h>=1;h=h/2){
            for (int i=h;i<a.length;i++){
                int j=i;
                Comparable temp=a[j];
                if (greater(a[j-h],a[j])){
                    while (j-h>=0&&greater(a[j-h],temp)){
                        a[j]=a[j-h];
                        j=j-h;
                    }
                }
                a[j]=temp;
            }
        }
    }
    private static boolean greater(Comparable v,Comparable w){
        return  v.compareTo(w)>0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

/**
归并排序
*/
public class Guibing {
    static Comparable[] assist;
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    public static void sort(Comparable[] a){
        assist=new Comparable[a.length];
        int lo=0;
        int hi=a.length-1;
        sort(a,lo,hi);
    }
    private static void sort(Comparable[] a,int lo,int hi){
        if (hi<=lo){
            return;
        }
        int mid=lo+(hi-lo)/2;
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);
    }
    private static void merge(Comparable[] a,int lo,int mid,int hi){
        int i=lo;
        int p1=lo;
        int p2=mid+1;
        while (p1<=mid&&p2<=hi){
            if(less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else {
                assist[i++]=a[p2++];
            }
        }
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        while (p2<=hi){
            assist[i++]=a[p2++];
        }
        for (int m=lo;m<=hi;m++){
            a[m]=assist[m];
        }
    }
}

/**
快速排序
*/
public class quiet {
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    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 sort(Comparable[] a){
        int lo=0;
        int hi=a.length-1;
        sort(a,lo,hi);
    }
    private static void sort(Comparable[] a,int lo,int hi){
        if (hi<=lo){
            return;
        }
        //分组
        int p=partition(a,lo,hi);
        //对分组后的两边进行排序
        sort(a,lo,p-1);
        sort(a,p+1,hi);
    }
    public static int partition(Comparable[] a,int lo,int hi){
        //保存分界值
        Comparable key=a[lo];
        //两个指针，一个指向起始值，一个指向末端的后一位
        int left=lo;
        int right=hi+1;
        while (true){
            //找到右边比分界值小的
            while (less(key,a[--right])){
                if (right==lo){
                    break;
                }
            }
            //找到左边比分界值大的
            while (less(a[++left],key)){
                if (left>=hi){
                    break;
                }
            }
            //交换左边和右边的值，小的放前面
            if (left>=right){
                break;
            }else {
                exch(a,left,right);
            }
        }
        //交换完之后并没有改变分界值的位置，最后再交换分界值（起始值）和right指向值的位置
        exch(a,lo,right);
        return right;
    }
}

/**
     * 基数排序
     * @param a
     */
    public static void sort(int[] a){
        //定义十个桶，从1~10，用来存放数字
        int[][] bucket=new int[10][a.length];
        //定义一个数组用来存放每个桶中元素的个数
        int[] bucketnum=new int[10];
        //找出最大值
        int max=a[0];
        for (int i=1;i<a.length;i++){
            if (i>max){
                max=a[i];
            }
        }
        //写出最大值的位数
        int maxlength=(max+"").length();
        //存放并取出数据
        for (int i=0,n=1;i<maxlength;i++,n*=10){
            for (int m=0;m<a.length;m++){
                int num=a[m]/n%10;
                bucket[num][bucketnum[num]]=a[m];
                bucketnum[num]++;
            }
            int index=0;
            for (int t=0;t<10;t++){
                if (bucketnum[t]!=0){
                    for (int j=0;j<bucketnum[t];j++){
                        a[index++]=bucket[t][j];
                    }
                }
                bucketnum[t]=0;
            }
        }
    }
}