java排序算法

插入排序

    /**     * 插入排序：利用每次交换前0到p-1上的元素已经处于排过序的状态；     * 第p趟，将位置p上元素向左移动，直到在前p+1个元素中找到正确的位置。     *     * @param a     * @param <T>     */    public static <T extends Comparable<? super T>> void insertionSort(T[] a) {        if (a == null || a.length == 0) {            return;        }        int j;        for (int p = 1; p < a.length; p++) {            T tmp = a[p];            for (j = p; j > 0 && tmp.compareTo(a[j - 1]) < 0; j--) {                a[j] = a[j - 1];            }            a[j] = tmp;        }    }

希尔排序

    /**     * 希尔排序：通过比较相聚一定间隔的元素来工作；     * 各趟比较所用的距离随着算法的进行而减小；     * 直到只比较相邻元素的最后一趟排序为止。     * 也叫 缩减增量排序     *     * @param a     * @param <T>     */    public static <T extends Comparable<? super T>> void shellSort(T[] a) {        if (a == null || a.length == 0) {            return;        }        int j;        for (int gap = a.length / 2; gap > 0; gap /= 2) {            for (int i = gap; i < a.length; i++) {                T tmp = a[i];                for (j = i; j >= gap && tmp.compareTo(a[j - gap]) < 0; j -= gap) {                    a[j] = a[j - gap];                }                a[j] = tmp;            }        }    }

堆排序

    /**     * 堆排序：利用二叉堆的buildHeap，以及deleteMin的复杂度为O(N log N)     * 考虑到使用deleteMin会依赖一个辅助数组存储最小值     * 所以直接创建一个max堆，并把最大值放在最后，再进行下滤，维持堆序     * 在剩下的数组中重复操作，节省了空间     *     * @param a     * @param <T>     */    public static <T extends Comparable<? super T>> void heapSort(T[] a) {        if (a == null || a.length == 0) {            return;        }        //构建二叉堆，max堆        for (int i = a.length / 2; i >= 0; i--) {            percDown(a, i, a.length);        }        //首先把最大值放在最后一个，最后的值放在第一个        //执行下滤操作，把原本的最后一个值放在合适的位置        //在剩下的length-1个值中重复上述操作        //节省了辅助数组        for (int i = a.length - 1; i >= 0; i--) {            T tmp = a[0];            a[0] = a[i];            a[i] = tmp;            percDown(a, 0, i);        }    }    /**     * 此处二叉堆从序号0开始，所以左子节点为2 * parent + 1     * 如果从1开始，则为2 * parent     *     * @param i     * @return     */    private static int leftChild(int i) {        return 2 * i + 1;    }    /**     * 构建二叉堆（max堆，最大值在第一个位置）     * 下滤操作，把小的值放下去     *     * @param a     * @param i     * @param n     * @param <T>     */    private static <T extends Comparable<? super T>> void percDown(T[] a, int i, int n) {        int child;        T tmp;        for (tmp = a[i]; leftChild(i) < n; i = child) {            child = leftChild(i);            if (child != n - 1 && a[child].compareTo(a[child + 1]) < 0) {                child++;            }            if (tmp.compareTo(a[child]) < 0) {                a[i] = a[child];            } else {                break;            }        }        a[i] = tmp;    }

归并排序

    /**     * 归并排序：通过递归将已排序的两个表进行合并     * 会用到辅助数组，以及数组拷贝的时间消耗     * 由于java的Comparator不容易内嵌，导致动态调用的开销会减慢速度     *     * @param a     * @param tmpArray     * @param left     * @param right     * @param <T>     */    public static <T extends Comparable<? super T>> void mergeSort(T[] a, T[] tmpArray, int left, int right) {        if (a == null || a.length == 0) {            return;        }        if (left < right) {            int center = (left + right) / 2;            mergeSort(a, tmpArray, left, center);            mergeSort(a, tmpArray, center + 1, right);            merge(a, tmpArray, left, center + 1, right);        }    }    public static <T extends Comparable<? super T>> void merge(T[] a, T[] tmpArray, int leftPos, int rightPos, int rightEnd) {        int leftEnd = rightPos - 1;        int tmpPos = leftPos;        int numElements = rightEnd - leftPos + 1;        while (leftPos <= leftEnd && rightPos <= rightEnd) {            if (a[leftPos].compareTo(a[rightPos]) < 0) {                tmpArray[tmpPos++] = a[leftPos++];            } else {                tmpArray[tmpPos++] = a[rightPos++];            }        }        while (leftPos <= leftEnd) {            tmpArray[leftPos++] = a[leftPos];        }        while (rightPos <= rightEnd) {            tmpArray[rightPos++] = a[rightPos];        }        for (int i = 0; i < numElements; i++, rightEnd--) {            a[rightEnd] = tmpArray[rightEnd];        }    }

快速排序

    private static <T extends Comparable<? super T>> void swap(T[] a, int m, int n) {        T tmp = a[m];        a[m] = a[n];        a[n] = tmp;    }    public static <T extends Comparable<? super T>> void quickSort(T[] a) {        quickSort(a, 0, a.length - 1);    }    /**     * 三数中值分割法，确保枢纽元不是最大或最小，减少比较次数     *     * @param a     * @param left     * @param right     * @param <T>     * @return     */    private static <T extends Comparable<? super T>> T pivot(T a[], int left, int right) {        int center = (left + right) / 2;        if (a[center].compareTo(a[left]) < 0) {            swap(a, center, left);        }        if (a[right].compareTo(a[left]) < 0) {            swap(a, left, right);        }        if (a[right].compareTo(a[center]) < 0) {            swap(a, center, right);        }        swap(a, center, right - 1);        return a[right - 1];    }    /**     * 快速排序：分治算法     * 1.取集合S中的一个元素v，作为枢纽元     * 2.将S-{v}划分为两个不相交的集合S1，S2,使S1中的元素都小于v，S2中的元素都大于v     * 3.返回[quickSort(s1),v,quickSort(s2)]     *     * @param a     * @param left     * @param right     * @param <T>     */    public static <T extends Comparable<? super T>> void quickSort(T[] a, int left, int right) {        if (left + 10 <= right) {            T pivot = pivot(a, left, right);            int i = left;            int j = right - 1;            for (; ; ) {                while (a[++i].compareTo(pivot) < 0) {                }                while (a[--j].compareTo(pivot) > 0) {                }                if (i < j) {                    swap(a, i, j);                } else {                    break;                }            }            swap(a, i, right - 1);            quickSort(a, left, i - 1);            quickSort(a, i + 1, right);        } else {            insertionSort(a, left, right);        }    }