七种排序java实现

package homework;

import static java.lang.System.gc;

public class Sort {
    private static int[] a ={1,2,3,4,0,-1,11,23,1,-9,1,2,3,4,5,6,7,8,9,99,88,77,665,55,44,33,22,11,23,24,25,-1,-22,-34,-54,-77};
    private  static int n = a.length;
    public static void main(String[] args) {
        radomSort();
        selectionSort();
        sortTest();
        radomSort();
        insertionSort();
        sortTest();
        radomSort();
        shellSort();
        sortTest();
        radomSort();
        popSort();
        sortTest();
        radomSort();
        mergeSort(0,n-1);
        sortTest();
        radomSort();
        quickSort(0,n-1);
        sortTest();
        radomSort();
        quick3Sort(0,n-1);
        sortTest();
        radomSort();
        heapSort();
        sortTest();
    }
    //堆排序
    public static void heapSort(){
        //建立最大堆
        for(int i=n/2;i>=0;i--){
            sortheap(i,n);
        }
        for(int i=0;i<n;i++){
            exchange(0,n-1-i);
            sortheap(0,n-i-1);
        }
    }
    //整理堆
    public static void sortheap(int i , int n){
        int leftchild = 2*i+1;
        int rightchild = 2*i+2;
        if(leftchild>=n) return;
        if(rightchild<n){
            if(a[i]>=a[leftchild] && a[i]>=a[rightchild]){
                return;
            }
            if(a[leftchild]<a[rightchild]){
                exchange(i,rightchild);
                sortheap(rightchild,n);
            }
            else{
                exchange(i,leftchild);
                sortheap(leftchild,n);
            }
        }
        else{
            if(a[i]<a[leftchild]) exchange(i,leftchild);
        }
    }
    //快排
    public static void quick3Sort(int l, int r){
        if(l>=r) return;
        int left=l,i=l+1,right=r;
        int temp = a[l];
        while(i<=right){
            if(a[i]<temp){
                exchange(i,left);
                left++;
                i++;
            }
            else if(a[i]>temp){
                exchange(i,right);
                right--;
            }
            else{
                i++;
            }
        }
        quick3Sort(l,left-1);
        quick3Sort(right+1,r);
    }
    public static void quickSort(int l, int r){
        if(l>=r){
            return;
        }
        int partionindex = partion(l,r);
        quickSort(l,partionindex-1);
        quickSort(partionindex+1,r);
    }
    //双向划分
    public static int partion(int l, int r){
        int temp = a[l];
        while(l<r){
            while(l<r){
                if(a[r]<temp){
                    a[l]=a[r];
                    break;
                }
                r--;
            }
            while(l<r){
                if(a[l]>temp){
                    a[r]=a[l];
                    break;
                }
                l++;
            }
        }
        a[l]=temp;
        return l;
    }
        public static void mergeSort(int l, int r){
        if(l>=r){
            return;
        }
        if(r-l==1){
            if(a[l]>a[r]){
                exchange(l,r);
            }
            return;
        }
        int mid =l+ (r-l)/2;
        mergeSort(l,mid);
        mergeSort(mid+1,r);
        merge(l,r,mid);
    }
    public static void merge(int l, int r, int mid){
        int[] arr = new int[r-l+1];
        int i=l,j=mid+1;
        for(int k = 0;k<r-l+1;k++){
            if(i>mid){
                arr[k] = a[j];
                j++;
            }
            else if(j>r){
                arr[k] = a[i];
                i++;
            }
            else if(a[i]>a[j]){
                arr[k] = a[j];
                j++;
            }
            else{
                arr[k] = a[i];
                i++;
            }

        }
        for(i = 0;i<r-l+1;i++){
            a[i+l] = arr[i];
        }
        arr=null;
        gc();

    }
    //冒泡排序
    public static void popSort(){
        for(int i = 0;i<n;i++){
            boolean isSorted=true;
            for(int j =0;j<n-i-1;j++){
                if(a[j]>a[j+1]){
                    exchange(j,j+1);
                    isSorted=false;
                }
            }
            if(isSorted){
                break;
            }
        }
    }
    //希尔排序
    public static void shellSort(){
        for(int g = n/2;g>0;g=g/2){
            for(int i = g;i<n;i++){
                for(int j = i;j >= g && a[j]<a[j-g];j=j-g){
                    exchange(j,j-g);
                }
            }
        }
    }
    //插入排序
    public static void insertionSort(){
        for(int i = 1;i<n;i++){
            for(int j=i-1;j>=0 && a[j]>a[j+1];j--){
                    exchange(j,j+1);
            }
        }
    }
    //选择排序
    public static void selectionSort(){
        for(int i = 0;i<n;i++){
            int minindex=i;
            for(int j =i+1;j<n;j++){
                if(a[minindex]>a[j]){
                    minindex=j;
                }
            }
            exchange(i,minindex);
        }
    }

    public static void exchange(int i, int j){

        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;

    }

    //随机算法
    public static void radomSort(){
        for(int i=n-1;i>=0;i--){
            int randomindex = (int) (Math.random() * (i + 1));
            exchange(randomindex,i);
        }

    }

    //测试排序结果正确性
    public static void sortTest(){
        for(int i = 0;i<n-1;i++){
            if(a[i]>a[i+1]){
                System.out.println("wrong");
                return;
            }
        }
        System.out.println("correct");
    }

}