数组排序算法（冒泡排序，选择排序，插入排序，快速排序，归并排序，堆排序）

public class ArraySort {
    /*
    冒泡升序排序
    它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）不符合升序或降序的要求就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
    这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
     时间复杂度：O（n）~O(n2)
     算法稳定性：元素相等时不交换不会破坏原有顺序所以是稳定排序
     */
    public static int[] maopaoSort(int[] array){
        if(array.length==0)return array;
        int begin=0;
        for(int len=array.length;len>=2;len--){
            for(int i=begin;i<len-1;i++) if(array[i]>array[i+1]) changePointValue(array,i+1,i);  //正序冒泡
            for (int j=len-2;j>0;j--)if(array[j]<array[j-1])changePointValue(array,j-1,j);//倒序反序冒泡
            begin++;
        }
        return array;
    }
/*
选择排序（Selection sort）是一种简单直观的排序算法。
它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。
以此类推，直到全部待排序的数据元素的个数为零。
时间复杂度：O（n2）
算法稳定性：不稳定   若某次寻得最大值时有最大值是两个相等的则会导致下标记录的是前者交换会导致顺序变化所以是非稳定排序
 */
public static int[] selectSort(int[] array){  //选择升序排序
        if(array.length==0) return array;
        for(int len=array.length;len>=2;len--){
            int tempIndex=0;
            for(int i=0;i<len-1;i++) if(array[tempIndex]<array[i+1]) tempIndex=i+1;  //选出最大值
            if(tempIndex!=len-1)  changePointValue(array,len-1,tempIndex); //与下标为len-1的元素交换
        }
        return array;
}
/*
插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
 时间复杂度：O(n2)  算法适用于少量，较为有序的数据的排序
 算法稳定性：稳定排序
 */
    public  static  int[] insertSort(int[] array){ //插入升序排序 稳定排序
            if(array.length<=1)return array;
           for(int i=1;i<array.length;i++){
                for(int j=i;j>0;j--){
                    if(array[j]<array[j-1])  changePointValue(array,j-1,j); //相等时不交换位置 稳定派排序
                    else  break;
                }
           }
            return array;
    }
/*
快速排序由C. A. R. Hoare在1960年提出。
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，
其中一部分的所有数据都比另外一部分的所有数据都要小，
然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
时间复杂度：O(nlog n)~O(n2)
算法稳定性：不稳定
 */
    public static  int[] quickSort(int[] array){  //快速全排 升序排序
        return quickSort(array,0,array.length-1);
    }

    public static int[] quickSort(int[] array ,int start,int end){  //快速排序 同选择排序一样是非稳定排序
        if(array.length<=1) return  array;
            int i=start; //前游标
            int j=end; //后游标
            while (i<j){
                while (i<j&&array[i]<=array[j]) j--; //后扫描
                if(i<j) {
                    changePointValue(array,i,j);
                    i++;
                }
                while (i<j&&array[j]>=array[i])i++; //前扫描
                if(i<j){
                    changePointValue(array,i,j);
                    j--;
                }
            }
            if(i>start+1)quickSort(array,start,i-1);  //排序目标前方的数组
            if(j<end-1) quickSort(array,j+1,end); //排序目标后方的数组
        return array;
    }
/*
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,
该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，
再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
时间复杂度：O（nlog n）
算法稳定在：稳定排序
 */
public   static  int[] mergeSort(int[] merge){
    return merge.length==1?merge:mergeSort(merge,0,merge.length-1);
}
public static  int[] mergeSort(int[] merge,int left, int right){
        if(left==right) return  new int[]{merge[left]};//若子数组只剩一个数则递归结束
        int mid=(left+right)/2;
        int[] leftArrray=mergeSort(merge,left,mid); //左子数组
        int[] rightArray=mergeSort(merge,mid+1,right);//右子数组
        int[] sumArray=new int[leftArrray.length+rightArray.length];//归并数组
        int leftPoint=0,rightPoint=0,sumPont=0;//左子数组游标 右子数组游标 合并数组游标
        //升序合归并
        while (leftPoint<leftArrray.length&&rightPoint<rightArray.length){ sumArray[sumPont++]=leftArrray[leftPoint]<rightArray[rightPoint]? leftArrray[leftPoint++]:rightArray[rightPoint++]; }
        while (leftPoint<leftArrray.length){sumArray[sumPont++]=leftArrray[leftPoint++];}
        while (rightPoint<rightArray.length){sumArray[sumPont++]=rightArray[rightPoint++];}
        return sumArray;//归并完成返回归并完成的数组
    }
/*
堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。非稳定排序
堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
 时间复杂度:O(nlog n)
 算法稳定性：不稳定
 */
public static int[] heapSort(int[] array){
    if(array.length<=1){
        return array;
    }
    //构建最大堆
    for(int i=array.length/2-1;i>=0;i--) adjustTree(array,i,array.length);
    //排序部分 将根节点的值与最后一个叶子节点交换 并从新调整受影响的树使使其依然满足最大堆的特点
    /*@Pram j 屏蔽与根节点交换过值的叶子节点
     */
    for (int j=array.length-1;j>0;j--){
        changePointValue(array,0,j);
        adjustTree(array,0,j);
    }
    return array;
}
private static void adjustTree(int[] array,int point,int length){
    int temp=array[point];
    for(int k=2*point+1;k<length;k=2*k+1){   //调整point所在树使其满足所有父节点大于其子节点
        if(k+1<length&&array[k+1]>array[k]) k++;  //若point的左节点小于右节点，则k指向右节点
        if(temp<array[k]){  //若子节点大于父节点则交换子与父节点的值
            array[point]=array[k];
            array[k]=temp;
        }
        point=k;
    }
}
private static void changePointValue(int[]array,int father,int children){
    int temp=array[father];
    array[father]=array[children];
    array[children]=temp;
}

}