数据结构-高级排序

 相比于速度较慢的简单排序---冒泡排序、插入排序和选择排序，在之前也介绍了一种使用递归算法的归并排序（速度虽快，但空间消耗大，需要数组大小的辅助空间）。希尔排序和快速排序是我们常用的两种高级排序算法，其中希尔排序的时间复杂度为O(N*(logN)²)，快速排序的时间复杂度为O(N*logN)，而且和归并排序不一样，不需要那么大的辅助空间。

一、希尔排序

希尔排序基于插入排序，但新增一个特性，可以使性能得到很大的提升。希尔排序对几千个数据量的，中等规模的排序是比较适用的。在最坏和平均条件情况下，执行的效果基本上一样。其实你可以将希尔排序看作N-增量排序算法。同时在每一趟排序结束后将N减小，直到N等于1。一般使用的算法为：N=(N-1)/3。

希尔排序实现代码如下：

/**
     * 针对array数组进行shell排序，排序的增量计算采用：h = (h-1)/3
     * 
     * @param array
     */
    public static void shellSort(double[] array) {
        if (array == null || array.length == 0) {
            return;
        }

        int nItems = array.length;
        int h = 1;
        while (h < nItems / 3) {
            h = h * 3 + 1;
        }

        while (h > 0) {
            for (int i = h; i < nItems; i++) {
                double tmpValue = array[i];
                int j = i;
                while (j > h - 1 && array[j - h] > tmpValue) {
                    array[j] = array[j - h];
                    j -= h;
                }
                array[j] = tmpValue;
            }
            h = (h - 1) / 3;
        }
    }

调用希尔排序的代码以及结果如下：

double[] array;
array = new double[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
System.out.println(Arrays.toString(array));
ShellSort.shellSort(array);
System.out.println(Arrays.toString(array));
System.out.println("********************");


结果是:
[10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0]
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]

 希尔排序中除了采用h=(h-1)/3这种序列外，还可以采用其他序列，唯一的要求就是，最后一个序列必须是1，及普通的插入排序。比如h=h/2，h=h/2.2等，其中第一种中，针对某些情况下，性能可能比插入排序还要差。一般而言，序列间的数字互质是非常重要的，也就是除了公约数1外，没有其他公约数，这样的序列可以更好的保证每一趟的排序能够保持前一次已排序好的效果。其中以h/2这种序列就违背了这种约束。还有一种比较常用的序列方案是：h=1(h<5)；h=(5h-1)/11(h>=5)

二、划分

划分是快速排序的基础，划分的意思是说，将数组分成两部分，第一部分的数据是小于等于标识位的数据的，第二部分的数据是大于标志位的数据的。

public static int partitionTwice(int[] array, int left, int right, int pivot) {
        if (left > right) {
            return -1;
        } else {
            int leftPro = left;
            int rightPro = right;

            while (true) {
                while (leftPro < rightPro && array[leftPro] < pivot) {
                    leftPro++;
                }

                while (rightPro > leftPro && array[rightPro] >= pivot) {
                    rightPro--;
                }

                if (leftPro == rightPro) {
                    break;
                }

                int tmpValue = array[leftPro];
                array[leftPro] = array[rightPro];
                array[rightPro] = tmpValue;
            }

            return leftPro == right ? right + 1 : leftPro;
        }
    }

 执行代码：

class PartitionApp {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
        System.out.println(array.length);

        System.out.println(Arrays.toString(array));
        int k = Partition.partitionOnce(array, 0, array.length, 4);
        System.out.println(Arrays.toString(array));
        System.out.println(k);
    }
}

22
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 1, 2, 3, 4, 0, 10, 11, 9, 10, 9, 8, 7, 6, 5, 8, 7, 6, 5]
8

  

三、快速排序

 快速排序是针对冒泡排序的一种改进。快速排序的实质是将要排序的数组分成两部分，第一部分的数据全部小于第二部分的数据，然后分别迭代这俩部分的数据即可。

实现的代码如下所示：

public class QuickSort {
    public static void quickSortByRecursive(int[] array) {
        if (array == null || array.length == 0) {
            return;
        } else {
            quickSortByRecursive(array, 0, array.length - 1);
        }
    }

    public static void quickSortByRecursive(int[] array, int left, int right) {
        if (right - left <= 3 || left == -1 || right == array.length) {
            int midValue = array[(left + right) / 2];
            int maxValue = Math.max(array[left], Math.max(midValue, array[right]));
            int minValue = Math.min(array[left], Math.min(midValue, array[right]));
            midValue = (array[left] + midValue + array[right]) - maxValue - minValue;
            array[left] = minValue;
            array[right] = maxValue;
            array[(right + left) / 2] = midValue;
            return;
        } else {
            int pivot = getPivot(array, left, right);
            int partition = partitionIt(array, left, right, pivot);
            quickSortByRecursive(array, left, partition - 1);
            quickSortByRecursive(array, partition, right);
        }
    }

    private static int getPivot(int[] array, int left, int right) {
        int mid = (left + right) / 2;
        if (array[left] > array[mid]) {
            if (array[right] > array[left]) {
                return array[left];
            } else if (array[right] > array[mid]) {
                return array[right];
            } else {
                return array[mid];
            }
        } else {
            if (array[right] > array[mid]) {
                return array[mid];
            } else if (array[right] > array[left]) {
                return array[right];
            } else {
                return array[left];
            }
        }
    }

    private static int partitionIt(int[] array, int left, int right, int pivot) {
        return Partition.partitionTwice(array, left, right, pivot);
    }
}

 使用快速排序以及结果如下：

class QuickSortApp {
    public static void main(String[] args) {
        int[] array;
        array = new int[] { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
        System.out.println(Arrays.toString(array));
        QuickSort.quickSortByRecursive(array);
        System.out.println(Arrays.toString(array));
    }
}

[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]