希尔排序

希尔排序是在插入排序的基础上进行排序的，它比插入排序的效率更加高，希尔排序是以间隔排序的，第一次以最大的间隔排序，逐渐减小间隔，直到排完序。

public static void sort(long[] arr){
//h为间隔 初始化为1 计算间隔的方法为h=h*3+1
        int h = 1;
        while(h <= arr.length/3){
            h = h * 3 +1;
        }
        while(h>0){
            long tmp = 0;
            for(int i = h;i<arr.length;i++){
                tmp = arr[i];
                int j = i;
    //比较数的大小 判断是否需要交换位置
                while(j>h-1 && arr[j-h]>=tmp){
                    arr[j] = arr[j-h];
                    j-=h;
                }
                arr[j] = tmp;
            }
            //减小间隔
            h = (h-1)/3;
        }
    }

快速排序

设置关键字，将数组中比关键字小的放到一个数组，将比关键字大的放到另外一个数组中，利用递归的方法，直排好序

/** * @Description 排序的方法 * @param arr 数组 * @param left 左边 * @param right 右边 * @param point 关键字（取得是数组最右边的数） * @return */
public static int qSort(long[] arr,int left,int right,long point){
        int leftPtr = left - 1;
        int rightPtr = right;
        while(true){
            //将比关键字小的排在左边
                while(leftPtr < rightPtr && arr[++leftPtr] < point);
            //将比关键字大的排在右边
                while(leftPtr < rightPtr && arr[--rightPtr] > point);
                if(leftPtr >= rightPtr){
                    break;
                }else{
                    long tmp = arr[leftPtr];
                    arr[leftPtr] = arr[rightPtr];
                    arr[rightPtr] = tmp;
                }
        }
        //为了使关键字在比关键字小的数的最右边
            long tmp = arr[leftPtr];
            arr[leftPtr] = arr[right];
            arr[right] = tmp;
            return leftPtr;
    }
    /** *利用递归的方法快速排序 */
    public static void dSort(long[] arr, int left,int right){
        if(right - left <= 0) {
            return;
        } else {
            //设置关键字
            long point = arr[right];
            //获得切入点，同时对数组进行划分
            int partition = qSort(arr, left, right, point);
            //对左边的子数组进行快速排序
            dSort(arr,left,partition - 1);
            //对右边的子数组进行快速排序
            dSort(arr,partition + 1, right);
        }
    }