数据结构之高级排序算法

一、希尔排序

希尔排序(缩小增量法) 属于插入类排序,由Shell提出，希尔排序对直接插入排序进行了简单的改进：它通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而使数据项大跨度地移动，当这些数据项排过一趟序之后，希尔排序算法减小数据项的间隔再进行排序，依次进行下去，进行这些排序时的数据项之间的间隔被称为增量，习惯上用字母h来表示这个增量。

具体代码实现：

package data.struct.algorithm;

//高级排序算法之希尔排序
class ArraySh {
    private int[] arr;
    private int nItems;

    public ArraySh(int maxSize) {
        arr = new int[maxSize];
        nItems = 0;
    }

    public void insert(int value) {
        arr[nItems++] = value;
    }

    // 显示数组内容
    public void displayArr() {
        for (int j = 0; j < nItems; j++) {
            System.out.print(arr[j] + " ");
        }
        System.out.println();
    }

    // 希尔排序
    public void shellSort() {
        // h的定义是:希尔排序的增量值
        int h = 1;
        int temp;
        int j;
        // 记录排序的次数
        int times = 0;
        /*
         * 常用的h序列由Knuth提出，该序列从1开始，通过如下公式产生： h = 3 * h +1 ;反过来程序需要反向计算h序列，应该使用
         * h=(h-1)/3
         */
        while (h < nItems / 3) {
            h = 3 * h + 1;
        }
        while (h > 0) {
            // 每个相同增量的子序列，希尔排序与直接插入排序的结合
            for (int i = h; i < nItems; i += h) {
                if (arr[i] < arr[i - h]) {
                    temp = arr[i];
                    j = i - h;
                    while (j >= 0 && arr[j] > temp) {
                        arr[j + h] = arr[j];
                        j -= h;
                    }
                    arr[j + h] = temp;
                    System.out.println("第" + (++times) + "次排序");
                    displayArr();
                }
            }
            // 计算下一个h的值
            h = (h - 1) / 3;
        }
    }
}

public class ShellSortTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int maxSize = 10;
        ArraySh arraySh = new ArraySh(maxSize);
        for (int j = 0; j < maxSize; j++) {
            // 随机产生数组的元素
            arraySh.insert((int) (Math.random() * 99));
        }
        arraySh.displayArr();
        System.out.println("---希尔排序步骤--");
        arraySh.shellSort();
    }

}

运行结果：

15 42 58 60 78 98 68 3 25 46 
---希尔排序步骤--
第1次排序
15 42 58 60 25 98 68 3 78 46 
第2次排序
15 25 42 58 60 98 68 3 78 46 
第3次排序
15 25 42 58 60 68 98 3 78 46 
第4次排序
3 15 25 42 58 60 68 98 78 46 
第5次排序
3 15 25 42 58 60 68 78 98 46 
第6次排序
3 15 25 42 46 58 60 68 78 98 

希尔排序的效率分析

上面程序在和直接插入法比较，会发现其与直接插入排序的差别在于：直接插入排序中的h会以1代替

Shell排序是不稳定的排序算法，它的空间复杂度是O(1),时间开销估计在O(N3/2)~O(N7/6)之间

二、快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递递归进行，以此达到整个数据变成有序序列。

具体代码实现：

package data.struct.algorithm;

public class QuickSortTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int arr[] = new int[10];
        for (int j = 0; j < arr.length; j++) {
            arr[j] = (int) (Math.random() * 99);
        }
        System.out.println("----排序前----");
        displayArr(arr);
        quickSort(arr, 0, arr.length - 1);
        System.out.println("----排序后----");
        displayArr(arr);

    }

    public static void quickSort(int arr[], int start, int end) {
        if (arr == null || end - start + 1 < 2) {
            return;
        } else {
            if (start < end) {
                int pivotKey = Partition(arr, start, end);
                quickSort(arr, start, pivotKey - 1);
                quickSort(arr, pivotKey + 1, end);
            }
        }
    }

    // 划分算法:通过一趟排序减法待排记录分割成队里的两部分，一部分关键字都小于枢纽值(pivotKey)，另一比分都大于枢纽值(pivotKey)
    public static int Partition(int[] arr2, int low, int high) {
        // 此处的划分算法，我们假定总是选择数组最左端的元素作为枢纽值
        int temp = arr2[low];
        while (low < high) {
            while (low < high && arr2[high] > temp) {
                high--;
            }
            arr2[low] = arr2[high];
            while (low < high && arr2[low] < temp) {
                low++;
            }
            arr2[high] = arr2[low];
        }
        arr2[low] = temp;
        return low;
    }

    public static void displayArr(int arr[]) {
        for (int j = 0; j < arr.length; j++) {
            System.out.print(arr[j] + " ");
        }
        System.out.println();
    }

}