数据结构--排序系列（插入排序，希尔排序，堆排序）Java代码实现

定理1：N个互异数的数组的平均逆序数是N(N-1)/4
定理二：通过交换相邻元素进行排序的任何算法平均都需要O（N^2）
package paixu;
public class Insert {
    public static void main(String[] args) {
       int  a[]= {9,6,8,4};
        insertionSort(a);
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
}
    public static  void  insertionSort(int [] a){
        int j;
        for(int p=1;p<a.length;p++){
            int tmp=a[p];
            j=p-1;
            while(j>=0&&tmp<a[j]){
                a[j+1]=a[j];
                j--;
            }
          a[j+1]=tmp;
        }
    }
}


希尔排序：
package paixu;
public class Shellsort {
    public static void main(String[] args) {
        int a[]={3,9,56,4,5,1};
        shellSort(a);
        for(int o:a)
        System.out.println(o);
    }
    public static void shellSort(int [] arr){
        int j;
        int len=arr.length;
        for(int val=len/2;val>0;val=val/2){
            for(int i=val;i<len;i++){
               int temp=arr[i];
                for(j=i;j>=val&&temp<arr[j-val];j-=val){
                    arr[j]=arr[j-val];
                }
                arr[j]=temp;
            }
        }
    }

}

堆排序：

package paixu;


public class heapsort {
    public static class ArrayUtils{
        public static void  printArray(int [] array){
            System.out.println("{");
            for(int i=0;i<array.length;i++){
                System.out.println(array[i]);
                if(i<array.length-1){
                    System.out.println(",");
                }
            }
            System.out.println("}");
        }
        public static void exchangeElements(int[] array,int index1,int index2){
            int temp=array[index1];
            array[index1]=array[index2];
            array[index2]=temp;
        }
    }




    public static void main(String[] args) {
       int [] array={25,23,32,1,14,21,2};
        heapSort(array);
         for(int arr:array){
             System.out.println(arr);
         }
    }
     public static void heapSort(int[] array){
        if(array==null||array.length<=1){
            return;
        }


         buildMaxHeap(array);
         for(int i=array.length-1;i>=1;i--){
            ArrayUtils.exchangeElements(array,0,i);
             maxHeap(array,i,0);
         }
     }


    private static void buildMaxHeap(int[] array){
        if(array==null||array.length<=1){
            return;
        }


        int half=array.length/2;
        for(int i=half;i>=0;i--){
            maxHeap(array,array.length,i);
        }
    }


    private static void maxHeap(int[] array,int heapSize,int index){
        int left=index*2+1;
        int right=index*2+2;


        int largest =index;
        if(left<heapSize&&array[left]>array[index]){
             largest=left;
        }


        if(right<heapSize&&array[right]>array[largest]){
            largest=right;
        }


        if(index!=largest){
            ArrayUtils.exchangeElements(array,index,largest);


            maxHeap(array,heapSize,largest);
        }
    }
}