直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序、归并排序--源码

直接上源码，有问题请留言：

public class Main {
    public static void main(String[] args) {
        int[] a={20,30,21,35,2,1};
        insert6(a);
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }

    //插入排序：将值插入到有序序列中
    //直接插入排序（插入排序）：将第i个值插入到前面的i-1长度的数组中，插入方法从i-1的数组的尾部往比较，直到找到合适的位置移动数组并插入
    //最坏O(n^2)、最好O(n)、平均O(n^2)
    //空间复杂度O(1)
    //属于稳定排序
    public static void insert1(int [] a){
        int temp=0;
        for(int i=1;i<a.length;i++){
            if(a[i-1]>a[i]){
                temp=a[i];
                int j;
                for(j=i-1;j>=0 && a[j]>temp;j--){
                    a[j+1]=a[j];
                }
                a[j+1]=temp;
            }
        }
    }

    //折半插入排序（插入排序）：直接插入排序的增强版
    //将第i个值插入到前面的i-1长度的数组中，插入方法从i-1的数组中利用折半查找，直到找到合适的位置移动数组并插入
    public static void insert2(int[] a){
        int high,low,temp,j,m;
        for(int i=1;i<a.length;i++){
            high=i-1;low=0;temp=a[i];
            while (low<=high){
                m=(low+high)/2;
                if(a[m]>temp)
                    high=m-1;
                else
                    low=m+1;
            }

            for(j=i-1;j>high;j--)
                a[j+1]=a[j];

            a[j+1]=temp;
        }
    }

    //希尔排序（插入排序）：分组直接插入排序
    //最坏O(n^2)、最好O(n)
    //空间复杂度O(1)
    //不稳定排序
     for(int step=a.length/2;step>=1;step=step/2){
            for(int i=step;i<a.length;i++){
                int j=i;
                int temp=a[j];
                while (j-step>=0 && a[j-step]>temp){
                    a[j]=a[j-step];
                    j=j-step;
                }
                a[j]=temp;
            }
        }

    //冒泡排序（交换排序）：两两比较，大值后移，每一轮长度减一
    //最坏O(n^2)、最好O(n)、平均O(n^2)
    //空间复杂度O(1)
    //属于稳定排序
    public static void insert4(int[] a){
        int temp;
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }

    //快速排序（交换排序）：设置low和high指针，分别指向头部和尾部，以头为基准点，通过high往前移和low往后移，当high==low是即为该基准点
    //最坏O(n^2)、最好O(nlogn)、平均O(nlogn)
    //空间复杂度O(logn)
    //属于不稳定排序
    public static void insert5(int[] a,int low,int high){
        if(low<high){
            int index=insert5Help(a,low,high);  //找到基准点

            insert5(a,0,index-1);  //以基准点为分割点、前面的小
            insert5(a,index+1,high); //以基准点为分割点、后面的大
        }
    }

    public static int insert5Help(int[] a,int low,int high){
        int temp=a[low];  //以首位置作为本次的基准点
        while (low<high){
            while (low<high && a[high]>=temp){   //首先操作high指针
                high--;
            }

            a[low]=a[high];  //找到比基准点小的值复制给a[low]

            while (low<high && a[low]<=temp){
                low++;
            }

            a[high]=a[low];
        }
        a[low]=temp;
        return low;  //返回找到的下一次的基准点
    }

    //选择排序:从无序序列中找到最小的值，与对应的头交换位置（与冒泡排序相似，冒泡排序大值后移）
    //最好、最坏时间复杂度都是O(n^2)
    //空间复杂度O(1)
    //属于不稳定排序
    public static void insert6(int[] a){
        int minIndex,temp;
        for(int i=0;i<a.length-1;i++){
            minIndex=i;
            for(int j=i+1;j<a.length;j++){
                if(a[j]<a[minIndex]){
                    minIndex=j;
                }
            }
            temp=a[i];
            a[i]=a[minIndex];
            a[minIndex]=temp;
        }
    }


//归并排序
    public static void mergeSort(int[] a,int start,int end){
        if(start<end){
            int mid=(start+end)/2;
            mergeSort(a,start,mid);
            mergeSort(a,mid+1,end);
            merge(a,start,mid,end);
        }
    }

    public static void merge(int[] a,int left,int mid,int right){
        int[] temp=new int[a.length];
        int p1=left,p2=mid+1,k=left;

        while (p1<=mid && p2<=right){
            if(a[p1]<=a[p2]){
                temp[k++]=a[p1++];
            }else
                temp[k++]=a[p2++];
        }

        while (p1<=mid)
            temp[k++]=a[p1++];
        while (p2<=right)
            temp[k++]=a[p2++];

        for(int i=left;i<=right;i++){
            a[i]=temp[i];
        }
    }
    
}