算法熟记-排序系列-快速排序

1. 简述

假设待排序数组为 int array[], 数组长度为n。快速排序是一个递归得方法。
当n==1的时候，停止排序。
当n>1的时候，首先选择数组中得一个元素作为基准，然后，把小于这个基准得元素放到这个基准的左边，把大于这个基准得元素放到这个元素得右边。
具体实现下面进行简单得说明，假设array[0]作为基准：
首先，存储基准得值，int tmp=array[0];
然后，两个指针，int left=0; int right = n-1;
bool flag_left = false; // 初始从右边开始
while(left < right) {
if(flag_left == true) {
如果当前值小于基准，则left++;
否则，array[right]=array[left]; right--; flag_left = false;
}
else {
如果当前值大于基准，则right--;
否则，array[left]=array[right]; left++; flag_left = true;

}

}
array[left] = tmp;
上面这段代码中，当轮到left指针执行时，right指针向的位置是可以使用的。当轮到right指针执行时，left指针指向的位置是可以使用的。
初始时，备份了array[0]，left指针指向的位置是可以使用 得，因此从右边开始。
最后，递归排序array[0]-array[left-1]和array[left+1]-array[n-1]两个部分的数组。
2. 复杂度

平均时间复杂度是O(N*logN)。当数组本身已经有序得情况下，需要比较得次数是N*N次。为了解决这样的问题，可以使用乱数快速排序，即每次基准是随即选择的。
稳定性属于非稳定排序。因为在与基准的比较过程中的交换很可能打破已有的顺序。

3. 代码

void quick_sort(int array[], int n) {
if(n <= 1)
return;
int tmp = array[0];
int left = 0; int right = n-1;
bool left_flag = false;
while(left < right) {
if(left_flag == true) { // 当前left指针
if(array[left] < tmp) {
left++;
}
else {
array[right] = array[left];
right--;
left_flag = false;
}
}
else { // 当前right指针
if(array[right] > tmp) {
right--;
}
else {
array[left] = array[right];
left++;
left_flag = true;
}
}
}
array[left] = tmp;
quick_sort(array, left); // array[0]-array[left-1]
quick_sort(array+left+1, n-left-1); // array[left+1], array[n-1]
}

实际上，快速排序是作为冒泡排序的改进提出来的，很多实现都是通过元素交换实现的，上面的代码是改进后的，更加有效率，把元素交换变成了元素的赋值。
一般来说，交换排序包括：冒泡排序和快速排序。
下面贴一个快速排序使用交换元素的实现：

void quicksort(int arr[],int beg,int end) {
if (end >= beg + 1) {
int piv = arr[beg], k = beg + 1, r = end;
// 从基准(array[0])右边的元素开始扫描，对于小于基准的元素跳过，对于大于基准的元素，交换到右边的位置上去,缩减右边的位置。
// 当右边可以交换的位置与当前元素重叠了，结束循环
while (k < r) {
if (arr[k] < piv)
k++;
else
swap(&arr[k], &arr[r--]);
}
// 交换基准
if (arr[k] < piv){
swap(&arr[k],&arr[beg]);
quicksort(arr, beg, k);
quicksort(arr, r, end);
}
else {
if (end - beg == 1)
return;
swap(&arr[--k],&arr[beg]);
quicksort(arr, beg, k);
quicksort(arr, r, end);
}
}
}

4. 参考资料

维基百科-快速排序 http://en.wikipedia.org/wiki/Quicksort