排序算法（Java）

直接插入排序

    /** 
    * @Description: 直接插入排序 
    * @Param: [a] 
    * @return: void 
    */ 
    public static void insertSort(int[] a){
        if (a.length==0)
            return;
        int tmp;
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                if(a[j]<a[j-1]){
                    tmp=a[j-1];
                    a[j-1]=a[j];
                    a[j]=tmp;
                }
            }
        }
    }

希尔排序

    /** 
    * @Description: 希尔排序 
    * @Param: [a] 
    * @return: void 
    */ 
    public static void shellSort(int[] a){
        if (a.length==0)
            return;
        int incrementNum= a.length/2;
        int tmp;
        while (incrementNum>=1){
            for (int i = 0; i < a.length; i++) {
                for (int j = i; j<a.length-incrementNum; j=j+incrementNum) {
                    if (a[j]>a[j+incrementNum]){
                        tmp=a[j];
                        a[j]=a[j+incrementNum];
                        a[j+incrementNum]=tmp;
                    }
                }
            }
            incrementNum/=2;
        }
    }

直接选择排序

    /** 
    * @Description: 直接选择排序 
    * @Param: [a] 
    * @return: void 
    */ 
    public static void selectSort(int[] a){
        if(a.length==0)
            return;
        for (int i = 0; i < a.length; i++) {
            int min=i;
            for (int j = i+1; j < a.length; j++) {
                if (a[j]<a[min])
                    min=j;
            }
            if(i!=min){
                int tmp=a[i];
                a[i]=a[min];
                a[min]=tmp;
            }
        }
    }

堆排序

    /**
    * @Description: 构造最大堆
    * @Param: [a, parent, length] parent表示非叶节点
    * @return: void
    */
    public static void heapAdjust(int[] a,int parent,int length){
        int child=2*parent+1;

        while(child<length){
            //如果有右孩子结点，并且右孩子结点大于左孩子结点，则选取右孩子结点
            if (child+1<length && a[child]<a[child+1]){
                child++;
            }

            //如果父结点的值已经大于子结点的值，直接返回
            if (a[parent]>=a[child])
                return;

            //把父结点与较大的孩子结点交换值
            int tmp=a[parent];
            a[parent]=a[child];
            a[child]=tmp;

            //孩子结点值改变之后，是否满足最大堆呢？继续向下调整
            parent=child;
            child=2*child+1;
        }
    }

    /**
    * @Description: 堆排序
    * @Param: [a]
    * @return: void
    */
    public static void heapSort(int[] a){
        if (a.length==0)
            return;

        //(a.length-2)/2是第一个非叶结点的位置
        //初始化最大堆
        for (int i = (a.length-2)/2; i >=0; i--) {
            heapAdjust(a,i,a.length-1);
        }

        //排序开始
        for (int i = a.length-1; i >0 ; i--) {
            //将第一个元素与最后一个元素交换位置
            int tmp = a[i];
            a[i]=a[0];
            a[0]=tmp;

            //重新调整，使改变后的树满足最大堆，注意，数组长度要-1
            heapAdjust(a,0,i);
        }
    }

冒泡排序

    /**
    * @Description: 冒泡排序
    * @Param: [a]
    * @return: void
    */
    public static void bubbleSort(int[] a){
        if (a.length==0)
            return;

        boolean flag=true;
        int tmp;
        while (flag){
            flag=false;
            for (int i = 1; i < a.length; i++) {
                for (int j = 0; j < a.length-i; j++) {
                    if (a[j]>a[j+1]){
                        flag=true;
                        tmp=a[j+1];
                        a[j+1]=a[j];
                        a[j]=tmp;
                    }
                }
            }
        }
    }

快速排序

    /**
    * @Description: 快速排序
    * @Param: [a, low, high]
    * @return: void
    */
    public static void quickSort(int[] a,int low,int high){
        int i=low,j=high,tmp=a[low];
        while (i<j){
            while (i<j && tmp<=a[j])
                j--;
            if (i<j){
                a[i]=a[j];
                i++;
            }
            while (i<j && a[i]<tmp)
                i++;
            if (i<j){
                a[j]=a[i];
                j--;
            }
        }
        a[i]=tmp;

        if(low<i) quickSort(a,low,i-1);
        if (i<high) quickSort(a,j+1,high);
    }

归并排序

    /** 
    * @Description:  
    * @Param: [a, low, mid, high] 
    * @return: void 
    */ 
    public static void merge(int[] a,int low,int mid,int high){
        int[] temp=new int[high-low+1];
        int i=low;
        int j=mid+1;
        int k=0;

        //先把较小的数移到新的数组中
        while (i<=mid &&j<=high &&j<a.length){
            if (a[i]<a[j]){
                temp[k++]=a[i++];
            }else {
                temp[k++]=a[j++];
            }
        }

        //把左边剩余的数组移入到数组
        while (i<=mid){
            temp[k++]=a[i++];
        }
        //把右边剩余的数组移入到数组
        while (j<=high && j<a.length){
            temp[k++]=a[j++];
        }

        //把新的数组中的数覆盖原数组，因为新数组是经过排序的
        for (int l = 0; l < temp.length; l++) {
            a[l+low]=temp[l];
        }
    }

    public static void mergeSort(int[] a,int low,int high){
        int mid=(low+high)/2;
        if (low<high){
            mergeSort(a,low,mid);
            mergeSort(a,mid+1,high);
            //左右归并
            merge(a,low,mid,high);
        }
    }