常见的排序算法

import java.util.Arrays;
import java.util.Random;

public class Sort {
    public static void main(String[] args) {
        Random random=new Random();
        func s=new func();
        int a[]=new int[20];
        for (int i=0;i<a.length;i++){
            a[i]=random.nextInt(100);
            System.out.print(a[i]+" ");
        }
//        冒泡排序
//        s.bubble(a);
//        选择排序
//        s.select(a);
//        插入排序
//        s.insert(a);
//        希尔排序
//        s.shell(a);
//        快速排序
//        s.quick(a,a.length,0,a.length-1);
//        System.out.println("快速排序");
//        for (int i=0;i<a.length;i++){
//            System.out.print(a[i]+" ");
//        }
//        归并排序
        System.out.println("归并排序");
        a=s.MergeSort(a);
        s.export(a);
    }
}

//默认从小到大排序
class func{
    //输出排序之后的结果
    public void export(int a[]){
        for (int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }
    //冒泡排序
    public void bubble(int a[]){
        System.out.println("冒泡排序");
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a.length-1;j++){
               if (a[j]>a[j+1]){
                   int t=a[j];
                   a[j]=a[j+1];
                   a[j+1]=t;
               }
            }
        }
        export(a);
    }
    //选择排序 稳定算法
    public void select(int a[]){
        System.out.println("选择排序");
        for (int i=0;i<a.length-1;i++){
            for (int j=i+1;j<a.length;j++){
                if (a[j]<a[i]){
                    int t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                }
            }
        }
        export(a);
    }
    //插入排序
    public void insert(int a[]){
        System.out.println("插入排序");
        int current=0;
        for (int i=0;i<a.length-1;i++){
            current=a[i+1];
            int index=i;
            while (index>=0&&current<a[index]){
                a[index+1]=a[index];
                index--;
            }
            a[index+1]=current;
        }
        export(a);
    }
    //希尔排序
    public void shell(int a[]){
        System.out.println("希尔排序");
        int t,gap=a.length/2;//初始步长为数组长度的一班
        while (gap>0){//一直排序，直到步长小于1
            for (int i=gap;i<a.length;i++){
                t=a[i];//存储选出来的那个数
                int index=i-gap;//标记这组数的前一位数
                while (index>=0&&a[index]>t){//排序
                    a[index+gap]=a[index];
                    index-=gap;//继续寻找前一位数
                }
                a[index+gap]=t;//
            }
            gap/=2;
        }
        export(a);
    }
    //快速排序
    public static void quick(int array[], int max, int low, int high) {
        int i, j;
        int temp;
        if(low < high) {
            i = low + 1;
            j = high;
            while(i < j) {
                if(array[i] > array[low]) {
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    j--;
                } else {
                    i++;
                }
            }
            if(array[i] >= array[low]) {
                i--;
            }
            temp = array[low];
            array[low] = array[i];
            array[i] = temp;
            quick(array, max, low, i);
            quick(array, max, j, high);
        }
    }
    //归并排序
    public static int[] MergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(MergeSort(left), MergeSort(right));
    }
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
    }
}