排序算法java实现总结

 //归并排序
 public static void mergeSort(int[] arr, int left, int right) {
           if(left>=right){
               return ;
           }
            int mid = (left+right)/2;
            mergeSort(arr,left,mid);
            mergeSort(arr,mid+1,right);
            merge(arr,left,mid,right);
        }
       public static void merge(int[] arr,int left,int mid ,int right){
            int[] temp = new int[arr.length];
            int i = left;
            int j = mid+1;
            int t = left;
            while(i<=mid && j<=right){
                if(arr[i]<=arr[j]){
                    temp[t++]=arr[i++];

                }else{
                    temp[t++]=arr[j++];

                }
            }
            while(i<=mid){
                temp[t++]=arr[i++];
            }
            while (j<=right){
                temp[t++]=arr[j++];
            }
           for (int k = left; k <=right ; k++) {
               arr[k]=temp[k];
           }
       }

//堆排序
public static  void adjustHeap(int i ,int size,int[] array){
            int temp = array[i];
            int index=2*i+1;
            while(index<size){
                if(index+1<size && array[index+1]> array[index])
                 index++; //选择两个子节点中值较大的
                if(array[index]>temp){
                    array[i] = array[index];
                    i=index;
                    index=index*2+1;
                }else
                {
                    break;
                }
            }
            array[i]=temp;
        }
      public static void heapSort(int [] array,int size){
            //构建大顶堆
            for(int i= size/2-1;i>=0;i--){//从右到左，从下到上构建堆
                adjustHeap(i,size,array);
            }
            
            //根据大顶堆对数组进行排序
            for(int k=size-1;k>=0;k--){
                int temp = array[k];
                array[k] = array[0];
                array[0] = temp; //交换堆顶元素和末尾元素
                adjustHeap(0,k,array);
            }
        }

//快速排序
    public static void quickSort(int [] A , int l ,int r){
            if(l>=r){
               return ;
            }
            int i=l , j=r;
            int X= A[l];
            if(l<r){
                while(i<j){
                    while(i<j && A[j]>X){
                        j--;
                    }
                    if(i<j){
                        A[i]=A[j];
                    }
                    while(i<j && A[i]<X){
                        i++;
                    }
                    if(i<j){
                        A[j]=A[i];
                    }
                }
                A[i]=X;
            }
            quickSort( A, l,i-1);//递归调用
            quickSort( A,i+1, r);

//选择排序
    public static void  Selectsort(int [] A){
       for(int i=0; i< A.length-1; i++){
           int minIndex = i;
           for(int j=i+1;j<A.length;j++){
               if(A[j]<A[minIndex]){
                   minIndex=j;
               }
           }
           int temp=A[i];
           A[i] = A[minIndex];
           A[minIndex]=temp;
       }
    }

//插入排序
public static void InsertSort(int [] A){
        int i ,j ,k;
        for( i =1; i<A.length; i++){
            for(j=i-1 ; j>=0; j--){
                if(A[i]>=A[j]){
                    break;
                }
            }
            if(j!=i-1){
                int temp = A[i];
                for(k=i-1;k>j;k--){
                    A[k+1]=A[k];
                }
                A[k+1]= temp;
            }
        }
    }

//冒泡排序
public static void Maopaosort1(int [] A){
        int i, j;
        for(i=0 ; i< A.length;i++){
            for(j=0;j<A.length-i-1;j++){
                if(A[j]>A[j+1])
                {
                    int temp =A[j];
                    A[j]=A[j+1];
                    A[j+1]=temp;
                }
            }
        }
    }