数据结构与算法复习（一）快速排序

快速排序的步骤是：
1、在数组中任意选择一个元素，称为轴值
2、扫描数组，将大于等于轴值的元素放到轴的右边，将小于轴值的元素放到轴的左边；固定轴的位置不动，
于是，数组被分为大于轴值和小于轴值的两个部分
4、对轴两边的数组递归执行1和2两个步骤

before sort :
开始时选择最后一个元素40为轴
27 28 1 59 48 63 40
扫描数组，将大于等于40的元素放到40的右边，将小于40的元素放到40的左边
同样的，固定40的位置不动，对40两边的数组递归进行上述过程
27 28 1 40 48 63 59
1 28 27 40 48 63 59
1 27 28 40 48 63 59
1 27 28 40 48 59 63
after sort :
1 27 28 40 48 59 63

快速排序是一种非稳定算法（比如数组84 84，排序时两者会交换）。
每一趟划分都需要对划分数组的所有元素扫描一遍，那么每一趟划分需要的时间为O(n)；
因此快速排序的时间复杂度取决于划分的次数，
理想的情况下，每次划分都能将数组对半分，那么只需要划分log2n次，则时间复杂度为O(nlog2n)；
最坏情况下，每次划分都选择到最大或最小元素作为轴，那么需要划分n次，则时间复杂度为O(n*n)；
被证明是：快速排序的平均时间复杂度为O(nlog2n)。

快速排序的空间复杂度：只需要一个数据缓存作为交换空间；每划分一次需要入栈一次，因此需要的栈空间为划分次数。因此快速排序的空间复杂度为划分次数。

综上所述：快速排序的性能取决于轴值的合理性，因此在排序时要采用一些办法选择合适的轴值，比如随机法。

算法实现代码如下。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* 用时间做种子产生随机数 */
#include <time.h>

void quicksort(int A[], int left, int right)
{
    /*
     * left：数组左下标
     * right：数组右下标
     */
    int l, r;

    if (A == NULL || left >= right) {
        return;
    }

    l = left;
    r = right - 1;
    while (l <= r) {
        while (A[l] < A[right]) {++l;}
        while (r >= left && A[r] >= A[right]) {--r;}

        if (r >= left) {
            exchange(A, l, r);
        }
    }

    if (r >= left) {
        exchange(A, l, r);
    }
    /* 将轴换到l的位置，并将l作为数组分割点 */
    exchange(A, l, right);
    quicksort(A, left, l - 1);
    quicksort(A, l + 1, right);
}

static void printA(int A[], int len)
{
    int i;

    for (i = 0; i < len; i++) {
        printf("%d ", A[i]);
    }
    printf("
");
}

int main(int argc, char **argv){
    int i, res, len;
    int A[50]; // = {-1,6,2,3,9,19};

    srand((int)time(NULL));
    len = rand() % 51; //51;
    printf("len is %d.
", len);

    srand((int)(time(NULL) + len));
    for (i = 0; i < len; i++) {
        A[i] = rand() % 100;
    }

    printf("before sort :
");
    printA(A, len);

    quicksort(A, 0, len - 1);

    printf("after sort :
");
    printA(A, len);

    return 0;
}