快速排序

算法思想：
（1）快速排序是一种非常高效的排序算法，它采用”分而治之”的思想，把大的拆分为小的，小的再拆分为更小的。其原理是：对于一组给定的记录，通过一趟排序后，将原序列分为两部分，其中前部分的所有记录均比后部分的所有记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中的所有记录均有序为止。
（2）具体算法步骤：
<1> 分解：将输入的序列 arr[m, … , n]划分成两个非空子序列 arr[m, … , k] 和 arr[k+1, … , n]，使arr[m, … , k]中任一元素的值不大于 arr[k+1, … , n]中任一元素的值。
<2> 递归求解：通过递归调用快速排序算法分别对arr[m, … , k] 和 arr[k+1, … , n]进行排序。
<3> 合并：由于对分解出的两个子序列的排序是就地进行的，所以在 arr[m, … , k] 和 arr[k+1, … , n]都排好序后，不需要执行任何计算arr[m, … , n]就已排好序。

实现代码如下：

#include <iostream>

void Sort(int arr[], int low, int high)
{
    int i = low;
    int j = high;
    if (low >= high) return;

    int index = arr[i]; // 选定轴值(选择轴值有多种方法，最简单的方法是选取第一个记录的关键码)

    while (i < j)
    {
        while (i < j && arr[j] >= index) // 从右侧向左侧扫描，扫描过程中i位置不变
            j--;
        if (i < j)
            arr[i++] = arr[j]; // 将“从右到左”扫描中得到的首个比轴值小的数，拷贝到轴值的位置(假设此时j＝6)。（轴值已经保存到了index中，不用担心被覆盖；注意，拷贝过后，此时的数组中有两个相同的元素(即arr[6])，即原轴值对应的i位置和此时j(j＝6)位置对应的数值是相同的，都是arr[6]。但这对之后的排序无影响，因为arr[6]对应的j(j＝6)的位置，是下面“从左到右”扫描时所得到的arr[i]所应该插入的位置）（此处还有另一种实现方式，即直接交换index和arr[j]的值，不使用拷贝）


        while (i < j && arr[i] < index) // 从左侧向右侧扫描，扫描过程中j位置不变
            i++;
        if (i < j)
            arr[j--] = arr[i];
    }

    arr[i] = index; // 轴值此时刚好位于其最终应处的位置。

    Sort(arr, low, i-1);
    Sort(arr, i+1, high);
}


void QuickSort(int arr[], int len)
{
    Sort(arr, 0, len-1);
}


int main(int argc, const char * argv[]) {

    int arr[] = {7,3,2,5,1,8,6,9,0,4};
    int len = sizeof(arr)/sizeof(int);

    QuickSort(arr, len);

    for (int i = 0; i < len; i++)
        printf("%d ", arr[i]);

    printf("\n");

    return 0;
}

补充：
（1）快速排序是对冒泡排序的一种改进，改进的着眼点是：在冒泡排序中，记录的比较和移动是在相邻位置进行的，记录每次交换只能后移一个位置，因而总的比较次数和移动次数较多。快速排序中，记录的比较和移动是从两端向中间进行的，关键码较大的记录一次就能从前面移到后面，关键码较小的记录一次就能从后面移动到前面，记录移动的距离较远，从而减少了总的比较次数和移动次数。
（2）当初始的序列整体或局部有序时，快速排序的性能将会下降，此时快速排序将退化为冒泡排序。
（3）快速排序的时间复杂度和空间复杂度：
<1> 平均时间复杂度：O(nlogn)
<2> 最坏时间复杂度：O(n2)
<3> 最好时间复杂度：O(nlogn)
<4> 空间复杂度：O(logn)