七种基本排序算法

import java.util.LinkedList;

/**
 * 七种基本排序算法
 * */
public class BaseSort {

    public static void main(String[] args) {
        int[] m={3,7,6,5,2,1,4,8,9};
        //bubbleSort(m);
        //chooseSort(m);
        //insertSort(m);
        //shellSort(m);
        //heapSort(m);
        //mergeSort(m,0,m.length-1,new int[m.length]);
        quickSort(m,0,m.length-1);
        for (int s:m) {
            System.out.print(s+",");
        }
    }

    private static int[] bubbleSort(int[] m){
        //冒泡
        for(int i=0;i<m.length;i++){
            for(int j=i+1;j<m.length;j++){
                if(m[j]<m[i]){
                    int k= m[j];
                    m[j]= m[i];
                    m[i]= k;
                }
            }
        }
        return m;
    }

    private static int[] chooseSort(int[] m){
        //简单选择
        for(int i=0;i<m.length;i++){
            int min=m[i];
            int index=i;
            for(int j=i+1;j<m.length;j++){
                if(m[j]<min){
                    min=m[j];
                    index = j;
                }
            }
            m[index] = m[i];
            m[i] = min;
        }
        return m;
    }

    private static int[] insertSort(int[] m){
        //插入排序
        for(int i=1;i<m.length;i++){
           for(int j=0;j<i;j++){
               if(m[i]<m[j]){
                   int k= m[i];
                   for(int s=i;s>j;s--){
                       m[s] = m[s-1];
                   }
                   m[j] = k;
                   break;
               }
           }
        }
        return m;
    }

    private static int[] shellSort(int[] m){
        //希尔排序
        int increment =  m.length;
        while (true){
            increment=(increment/3)+1;
            for(int i=0;i<increment;i++){
                for(int j=i+increment;j<m.length;j+=increment){
                    int k= j;
                    //插入排序
                    while((k-increment)>=0&&(m[k]<m[k-increment])){
                        int s= m[k];
                        m[k] = m[k -increment];
                        m[k-increment] = s;
                        k-=increment;
                    }
                }
            }

            if(increment==1){
                break;
            }
        }
        return m;
    }

    private static int[] heapSort(int[] m) {
     //堆排序 https://www.cnblogs.com/jingmoxukong/p/4303826.html
     //构造初始堆
        for(int i= m.length/2;i>=0;i--){
           //最多m.length/2个父节点
            heapAdjust(m,i,m.length);
        }
     //替换首尾元素，并重新调整堆
        for(int i=m.length-1;i>0;i--){
            int a= m[i];
            m[i] = m[0];
            m[0] = a;
            heapAdjust(m,0,i);
        }
        return m;
    }

    private static void heapAdjust(int[] m, int i, int length) {
        //堆调整
        int tmp = m[i];
        int maxIndex = 2*i+1;
        while(maxIndex<length){
            if(maxIndex+1<length&&(m[maxIndex+1]>m[maxIndex])){
                maxIndex = maxIndex+1;
            }
            if(m[maxIndex]<tmp){
                break;
            }
            m[i] = m[maxIndex];
            i= maxIndex;
            maxIndex=2*i+1;
        }
        m[i] = tmp;
    }

    private static void mergeSort(int[] m,int left, int right,int[] tmp) {
        //归并排序 https://blog.csdn.net/k_koris/article/details/80508543
        if(left<right){
            int mid = (left+right)/2;
            mergeSort(m,left,mid,tmp);
            mergeSort(m,mid+1,right,tmp);
            merge(m,left,right,mid,tmp);
        }
    }

    private static int[] merge(int[] m,int left,int right,int mid,int[] tmp) {
        int i= left;
        int j= mid+1;
        int t=0;
        while(i<=mid&&j<=right){
            if(m[i]<m[j]){
                tmp[t++]= m[i++];
            }else{
                tmp[t++]= m[j++];
            }
        }
        while(i<=mid){
            tmp[t++]= m[i++];
        }
        while(j<=right){
            tmp[t++] = m[j++];
        }
        t= 0;
        while(left<=right){
            m[left++] = tmp[t++];
        }
        return m;
    }

    private static void quickSort(int[] m,int l ,int r) {
        //快速排序 https://www.cnblogs.com/skywang12345/p/3596746.html
        if(l<r){
            int i=l;
            int j=r;
            int x=m[i];
            while(i<j){
                while((i<j)&&m[j]>x){
                    j--;
                }
                if(i<j){
                    m[i++]=m[j];
                }
                while((i<j)&&m[i]<x){
                    i++;
                }
                if(i<j){
                    m[j--]=m[i];
                }
            }
            m[i] =x;
            quickSort(m,l,i-1);
            quickSort(m,i+1,r);
        }
    }

}