快速排序

Wiki

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

算法

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

步骤为：

1. 从数列中挑出一个元素，称为”基准”（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
   递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

实现

C语言（递归版）

    void swap(int *x, int *y) {
        int t = *x;
        *x = *y;
        *y = t;
    }
    void quick_sort_recursive(int arr[], int start, int end) {
        if (start >= end)
            return;
        int mid = arr[end];
        int left = start, right = end - 1;
        while (left < right) {
            while (arr[left] < mid && left < right)
                left++;
            while (arr[right] >= mid && left < right)
                right--;
            swap(&arr[left], &arr[right]);
        }
        if (arr[left] >= arr[end])
            swap(&arr[left], &arr[end]);
        else
            left++;
        quick_sort_recursive(arr, start, left - 1);
        quick_sort_recursive(arr, left + 1, end);
    }
    void quick_sort(int arr[], int len) {
        quick_sort_recursive(arr, 0, len - 1);
    }

分析

swap函数 : 交换两个数；
step1(line9)： 取数组最后一个元素作为基准数；
step2(line10)：规定分区的左右界限；
step3(line11)：界定循环的条件(while循环)；
step3(line12&&line13)：找到比基准数大的数字left
step3(line14&&line15)：找到比基准数小的数字right
step3(line16)：将上两步找到的两个数（left,right）进行交换
step4(line18~line21)：step3做完的前提是left==right，此时判断基准数和left的大小，如果基准数小于left，则进行交换，即把基准数放到整个数组的中间，否则不交换；

以上就是一个“分区”排序完成的过程，为什么叫做“分区”？接下来就是分而治之：

step5(line22)：刚刚排序完成的时候，left==right，也就是说，left左边都是比基准数小的，left右边都是比基准数大的数字。那么把left左边划分为一个“分区”，界限为0~left-1，再进行step1~step4的过程。
step5(line23)：同理右边也是一个分区，界限为left+1~end，进行step1~step4的过程。

由此不断的进行分区与排序，也就是递归的过程，递归的结束标志是start>=end。

C语言（迭代版）

    typedef struct _Range {
        int start, end;
    } Range;
    Range new_Range(int s, int e) {
        Range r;
        r.start = s;
        r.end = e;
        return r;
    }
    void swap(int *x, int *y) {
        int t = *x;
        *x = *y;
        *y = t;
    }
    void quick_sort(int arr[], const int len) {
        if (len <= 0)
            return; 
        //r[]模拟堆叠,p为数量,r[p++]为push,r[--p]为pop且取得元素
        Range r[len];
        int p = 0;
        r[p++] = new_Range(0, len - 1);
        while (p) {
            Range range = r[--p];
            if (range.start >= range.end)
                continue;
            int mid = arr[range.end];
            int left = range.start, right = range.end - 1;
            while (left < right) {
                while (arr[left] < mid && left < right)
                    left++;
                while (arr[right] >= mid && left < right)
                    right--;
                swap(&arr[left], &arr[right]);
            }
            if (arr[left] >= arr[range.end])
                swap(&arr[left], &arr[range.end]);
            else
                left++;
            r[p++] = new_Range(range.start, left - 1);
            r[p++] = new_Range(left + 1, range.end);
        }
    }