排序算法篇_快速排序法

image

  快速排序（Quick Sort）法和冒泡排序法类似，都是基于交换排序思想的。快速排序对冒泡排序法进行了改进，从而具有更高的执行效率。

快速排序法

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

1. 首先设定一个分界值，通过该分界值将数组分成左右两部分。
2. 将大于等于分界值的数据集中在数组的右边，小于分界值的数据集中在数组的左边。此时左边的部分中各元素都小于等于分界值，而右边部分中的各元素大于分界值。
3. 然后，左边和右边的数据可以独立的排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样将左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似的处理。
4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。向左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

  为了更清晰地理解快速排序算法的执行过程，这里我们举一个实际的数据例子来一步步的执行快速排序算法。对于8个整型数据69、62、89、37、97、17、28、49，这是一组无序数据。对于其执行快速排序过程，如下图所示。快速排序算法执行步骤如下：

1. 首先选一个分界值，这里选第一个数据69作为分界值。在变量left中保存数组的最小序号0，在变量right中保存数组的最大序号7，在变量base中保存分界值69.
2. 从数组的右侧开始，逐个取出数据与分界值69比较，直到找到比base小的数据为止。这里，数组最右侧的元素A[right]的值49就比base变量中保存的69小。
3. 将右侧比基准base小的数（数组元素A[right]中的数）保存到A[left]（A[0]）元素中。
4. 接下来，从数组左侧开始，逐个去除元素与分界值69比较，直到找到比分界值69大的数据为止。这里数组最左侧的元素A[left]（即A[0]）的值为49，比base的值小，将left自增1（值为1）。再取A[left]（A[1]）的值62与base的值69比较，62小于69，继续讲left自增1（值为2）。再取A[left]（A[2]）的值89与base比较，因89大于69，结束查找。
5. 将左侧比分界值69大的数（数组与元素A[2]）保存到A[right]（A[7]）元素中。
6. 将分界值69中的值保存到A[left]（A[2]）中，最后得到结果如图所示：

image

经过这一次的分割，base数据左侧（也就是left所指向的数据）的数比分界值69小，而base数据右侧的数比base大。

7. 接下来，通过递归调用，将left左侧的数据进行同样的排序，再将left右侧的数据进行同样的排序。

经过这样的递归调用，最终可将数据完成排序操作。

快速排序算法的示例代码如下：

void quickSort(int[] datas, int left, int right) {
        int base, t, leftTemp, rightTemp;
        leftTemp = left;
        rightTemp = right;
        // 分界值
        base = datas[(left + right) / 2];
        while (leftTemp < rightTemp) {
            while (datas[leftTemp] < base) {
                ++leftTemp;
            }
            while (datas[rightTemp] > base) {
                --rightTemp;
            }
            if (leftTemp <= rightTemp) {
                t = datas[leftTemp];
                datas[leftTemp] = datas[rightTemp];
                datas[rightTemp] = t;
                --rightTemp;
                ++leftTemp;
            }
        }
        if (leftTemp == rightTemp) {
            leftTemp++;
        }
        if (left < rightTemp) {
            quickSort(datas, left, leftTemp - 1);
        }
        if (leftTemp < right) {
            quickSort(datas, rightTemp + 1, right);
        }
    }

  在这里，输入参数datas一般为一个数组的首地址，输入参数left指向数组最左边的值，输入参数right指向最右边的值。

  程序首先确定分界值为数组中间位置的值，当然也可以选在其他位置，比如数组的第一个数据。然后按照快速排序法的思路进行处理。接着，通过递归调用，处理分界值左侧的元素和右侧的元素。

快速排序算法的实例

  有了前面快速排序算法的基本思想和算法之后。这里通过一个完整的例子来说明快速排序算法在整型数组的应用，程序示例如下：

 public class QuickSort {
    static final int SIZE = 18;
    public static void quickSort(int[] datas, int left, int right) {
        int base, t, leftTemp, rightTemp;
        leftTemp = left;
        rightTemp = right;
        // 分界值
        base = datas[(left + right) / 2];
        while (leftTemp < rightTemp) {
            while (datas[leftTemp] < base) {
                ++leftTemp;
            }
            while (datas[rightTemp] > base) {
                --rightTemp;
            }
            if (leftTemp <= rightTemp) {
                t = datas[leftTemp];
                datas[leftTemp] = datas[rightTemp];
                datas[rightTemp] = t;
                --rightTemp;
                ++leftTemp;
            }
        }
        if (leftTemp == rightTemp) {
            leftTemp++;
        }
        if (left < rightTemp) {
            quickSort(datas, left, leftTemp - 1);
        }
        if (leftTemp < right) {
            quickSort(datas, rightTemp + 1, right);
        }
    }
    public static void main(String[] args) {
        int[] datas = new int[SIZE];
        int i;
        for (i = 0; i < SIZE; i++) {
            datas[i] = (int) (100 + Math.random() * (100 + 1));
        }
        System.out.print("排序前的数组为：\n");
        for (i = 0; i < SIZE; i++) {
            System.out.print(datas[i] + " ");
        }
        System.out.print("\n");
        quickSort(datas,0,SIZE - 1);
        System.out.print("排序后的数组为：\n");
        for (i = 0; i < SIZE; i++) {
            System.out.print(datas[i] + " ");
        }
    }
}

程序执行的结果如下：

image