快速排序的复杂度分析以及使用插入排序优化的快速排序

首先，对快速排序分析可知，在一个包含n个元素的数组上运行快速排序时，记总共的两个元素之间的比较次数为X，则快速排序的运行时间为$O(n+X)$（算法导论第三版7.4.2节引理7.1）。因此，必须了解算法在什么时候对数组中的两个元素进行比较，什么时候不进行比较。
将数组A中的各个元素重新命名为$z_1,z_2,z_3,...,z_n$，其中$z_i$是数组中第i小的元素。定义$Z_{ij}={z_i,z_{i+1},z_{i+2},...,z_j}$为$z_i$和$z_j$之间（含i和j）的元素集合。定义指示器随机变量：

$X_{ij}=I\{z_i与z_j进行比较\}$

则算法的总共的比较次数为：

$X=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}X_{ij}$

对上述式子两边取期望可得：

$E[X]=E[\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}X_{ij}]=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}E[X_{ij}]=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}Pr\{z_i与z_j进行比较\}$

通常，假设每个元素的值是互异的，因此，一旦一个满足$z_i<x<z_j$的主元被选择后，$z_i$和$z_j$就再也不可能被比较了，因为$z_i$和$z_j$已经被划分到两个不同的划分中。然而，若是$z_i$在$Z_{ij}$中的其他所有元素之前被选为主元，那么$z_i$将和$Z_{ij}$中除了它自身之外的所有元素进行比较。因此，$z_i$和$z_j$当且仅当$Z_{ij}$中第一个被选为主元的元素是$z_i$或者$z_j$。
接着计算这一事件发生的概率。在任意一个$Z_{ij}$内的元素被选择为主元之前，整个集合均在一个划分的同一个分区之中。因此，每个$Z_{ij}$中的元素被选为主元的概率相等。因为集合中有$j-i+1$个元素，并且主元的选择是独立且随机的，所以任何元素首先被选为主元的概率为$\frac{1}{j-i+1}$。于是：

$Pr\{z_i于z_j相比较\}=Pr\{z_i或者z_j是集合中首先被选择作为主元的元素\}=\frac{2}{j-i+1}$

所以有：

$E[X]=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}\frac{2}{j-i+1}$

所以，可以有：

$E[X]=\sum_{i=1}^{n-1} \sum_{j=i+1}^{n} \frac{2}{j-i+1} =\sum_{i=1}^{n-1} \sum_{k=1}^{n-i} \frac{2}{k+1}\lt\sum_{i=1}^{n-1} \sum_{k=1}^{n-i} \frac{2}{k}=\sum_{i=1}^{n-1} O(\lg{n})=O(n\lg{n})$

由此可得，在输入元素均不相同的情况下，随机化的快速排序算法的期望运行时间是$O(n\lg{n})$。
对于上式，又有：

$E[X]=\sum_{i=1}^{n-1} \sum_{j=i+1}^{n} \frac{2}{j-i+1} =\sum_{i=1}^{n-1} \sum_{k=1}^{n-i} \frac{2}{k+1}\ge\sum_{i=1}^{n-1} \sum_{k=1}^{n-i} \frac{2}{2k}\ge\sum_{i=1}^{n-1} \Omega(\lg{n})=\Omega(n\lg{n})$

所以，又有，随机化的快速排序算法的期望运行时间为$\Omega(n\lg{n})$。由上可知，随机化的快速排序算法的期望运行时间为$\Theta(n\lg{n})$。
当输入数据已经几乎有序时，插入排序的速度很快。在实际应用中，可以利用这一特点来提高快速排序的速度。当对一个长度小于k的子数组调用快速排序时，可以让它不做任何处理就返回。当上层快速排序调用返回后，对整个数组进行插入排序来完成排序过程。该算法的期望时间复杂度为$O(nk+n\lg(n/k))$。该算法的时间复杂度分析如下：
对于快速排序结束后的插入排序，假设每一小结的插入排序时间复杂度为O(k^2)，则n/k个小结的时间复杂度为$\frac{n}{k}O(k^2)=O(nk)$。
对于随机的快速排序过程，时间复杂度是$O(n\lg(n/k))$，网上很多解答说这个利用指示器随机变量，然后计算j与i的距离大于k的均值即可，但是笔者认为，在划分过程中，j于i之间的距离小于k时的比较也可能出现，所以不可以单单这样计算，然而想不出正确解法，故留待之后解决。
C语言实现优化的快速排序如下：

void insertion_sort(int *source, int head, int tail) {
    if (head > tail) {
        fprintf(stderr, "Error head and tail\n");
        return;
    }
    int i = head + 1;
    int j = head;
    int temp;
    for (i = head + 1; i <= tail; i++) {
        temp = source[i];
        for (j = i - 1; j >= head && source[j] > temp; j--) {
            source[j + 1] = source[j];
        }
        source[j + 1] = temp;
    }
}

int randomized_partition(int *source, int head, int tail) {
    swap(source + rand() % (tail - head + 1) + head, source + tail);
    int x = source[tail];
    int i = head - 1, j = head;
    for (j = head; j < tail; j++) {
        if (source[j] <= x) {
            i++;
            swap(source + j, source + i);
        }
    }
    swap(source + tail, source + i + 1);
    return i + 1;
}

void limited_quick_sort(int *source, int head, int tail, int k) {
    if (tail - head >= k)
        return;
    int mid = randomized_partition(source, head, tail);
    limited_quick_sort(source, head, mid - 1, k);
    limited_quick_sort(source, mid + 1, tail, k);
}

void insertion_optimized_quick_sort(int *source, int head, int tail, int k) {
    limited_quick_sort(source, head, tail, k);
    insertion_sort(source, head, tail);
}