Java实现几种排序算法

package sort_test;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = {23,54,36,64,7,3,67,85,66,44};
//      int n=a.length;
//      for(int i=n/2-1;i>=0;i--){//i=n/2-1为非叶子结点最后一个父节点
//          build_max_heap(a,i,n);
//      }
        merge_sort(a,0,a.length-1);
        for(int i:a){
            System.out.println(i);
        }
        
//      int nn = binarySearch2(a,36,0,a.length-1);
//      System.out.println(nn);
    }
    
    //is item v less than w?
    private static boolean less(int v,int w){
        return v < w;
    }
    //swap item in array a[] at index i with the one in index j
    private static void exch(int[] a,int i,int j){
        int temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    
    //基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换，然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止
    public static void select_sort(int[] a){
        int n=a.length;
        for(int i=0;i0;j--){
                if(less(a[j],a[j-1])){
                    exch(a,j-1,j);
                }
            }
        }
    }
    //将未排序部分元素逐个排序插入,但是插入的过程不同,需要每次求一个中间位置,和中间位置元素比较大小,然后根据大小情况,将高位左移或者将低位右移
    public static void binary_insert_sort(int[] a){
        int n=a.length;
        int i,j,temp,low,mid,high;
        for(i=1;itemp){
                    high=mid-1;
                }else{
                    low=mid+1;
                }
            }
            for(j=i-1;j>high;j--){//将high+1 ~ i的所有元素后移一位
                a[j+1]=a[j];
            }
            a[high+1]=temp;//插入元素
        }
    }
    //分组的插入排序
    public static void shell_sort(int[] a){
        int n=a.length;
        int h=1;
        while(h=1){
            for(int i=h;i=h&&less(a[j],a[j-h]);j-=h){
                    exch(a,j,j-h);
                }
            }
            h/=3;
        }
    }
    
    public static void quick_sort(int[] a,int left,int right){
        int ileft=left;
        int iright=right;
        int imiddle=(ileft+iright)/2;
        int temp=a[imiddle];
        
        while(true){
            while(a[iright]>temp) iright--;
            while(a[ileft]=iright) break;
            exch(a,ileft,iright);
        }
        if(ileft!=left) quick_sort(a,left,ileft-1);
        if(iright!=right) quick_sort(a,iright+1,right);
    }
    //构建最大堆
    private static void build_max_heap(int[] a,int parent,int length){
        int lchild=2*parent+1;
        int rchild=2*parent+2;
        int largest=parent;
        if(lchilda[largest]){
            largest=lchild;
        }
        if(rchilda[largest]){
            largest=rchild;
        }
        if(largest!=parent){
            exch(a,largest,parent);
            build_max_heap(a,largest,length);
        }
    }
    public static void heap_sort(int[] a){
        //建堆
        int n=a.length;
        for(int i=n/2-1;i>=0;i--){//i=n/2-1为非叶子结点最后一个父节点
            build_max_heap(a,i,n);
        }
        //已经是最大堆，排序
//      for(int j=n-1;j>0;j--){
//          exch(a,0,j);
//          build_max_heap(a,0,--n);
//      }
        while(n>0){
            exch(a,0,--n);
            build_max_heap(a,0,n);
        }
    }
    
    private static void merge(int[] a,int low,int mid,int high){
        
        int i=low;//左指针
        int j=mid+1;//右指针
        int k=0;
        int[] temp=new int[high-low+1];
        // 把较小的数先移到新数组中 
        while(i<=mid&&j<=high){
            if(a[i]