标签：快速排序
首先简单谈下快速排序的特点，时间复杂度O(nLog n)，最差时间复杂度O(n^2)，平均时间O(nLog n).因为用到了函数栈，空间复杂度为O(lg n),最差为O(n).是一种不稳定的排序方法。基本思想是分治法，这位大大的http://blog.csdn.net/morewindows/article/details/6684558 讲的非常清楚了，分治法+挖坑法，我就不多说了。就是以某个数为参照，使得左边的都小于他，右边的数都大于他。然后对他的左右两个区间采取同样的方法进行递归。
就其整体实现而言，有两大种思路，一是双边扫描，二是单边扫描。下面分别来上程序:
双边扫描是谭浩强书中的方法，个人觉得比下面的单边扫描更好理解，也是博文里采用的方法。下面看程序:
void quickSort1(int* x, int l, int r){
if(l < r){
int i = l, j = r, key = x[l];
while(i < j){
while( i < j && x[j] >= key){
j--;
}
if(i < j){
x[i++] = x[j];
}
while(i < j && x[i] <= key){
i++;
}
if(i < j){
x[j--] = x[i];
}
}
cout<<"i = " <<i<<" j = "<<j<<endl;
x[i] = key;
quickSort1(x, l, i-1);
quickSort1(x, i+1, r);
}
}双边排序的要点: 1、最初的if一定要有，这是最后递归出来的标志位。2，为了找到一个数使它的左边都大于它，右边都小于它，要多次循环，这个循环就是大while循环。3、双边排序不需要swap，即无需交换。
上面的双边排序，出来一次大while循环，要从两边进行多次。单边扫描，则只需从左走到右就能完成一次 快排。
void quickSort2(int x[], int l, int r){
if(l >= r)
return;
int m = l;
for(int i = l + l; i <= r; i++ ){
if(x[i] < x[l]){
swap2(x[++m], x[i]);
}
}
swap2(x[l], x[m]);
quickSort2(x, l, m - 1);
quickSort2(x, m + 1, r);
}
void swap2(int &a,int &b){
if(a==b) return;//对同一地址的数据交换，会使其结果为0
a=a^b;
b=a^b;
a=a^b;
} 代码是不是更简单了？程序先进行判断，如果l>=r直接return，这点跟双边扫描的if一个意思，都是为递归创造结束的标志。然后用m记录最左边的那个的索引，这里默认的是第一个，即x[l]的索引。[注，m的初始值不一定指向key！，仅仅是指向最左边的。]然后进入扫描，直接从l + 1开始，如果右边的小于key，就让x[++m]和x[i]交换。如果右边的大于key，则不进行任何操作。这里有个特例，如果l = 0， 则m = 0.如果x[1]小于x[0]，则让x[1] 和x[1]进行交换，也就等于没交换。如果数组是5 4 3 2 1，则这里的交换就失效了。 再往后看，直到for循环结束，走出循环，让最后m指的位置的数和最初的key进行交换。如上面 5 4 3 2 1,则第一次快排的结果是 1 4 3 2 5，只有for出来后的那次swap才起作用。这里的m有个特殊含义，即指向小于key的最右边的那个数。所以出来后才用它(x[m])和key(即x[l])进行交换。单边扫描的特点:
1、程序需要交换；
2、更有冒泡法的色彩；冒泡的目的不是让最大的数沉到最右边，而是让小于key的都左移，找到分界索引m。使之和key进行交换。
3、此版本的的单边扫描属于最基础的，还可以优化。
本想测出两个算法的时间 消耗差异，遗憾的是c++获得程序运行时间太费劲了，弄半天没弄成。下面附上完整程序:
//============================================================================
// Name : QuikSort.cpp
// Author : YanZi
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include <malloc.h>
using namespace std;
void swap1(int a, int b);
void printArray(int* in, int n);
void quickSort1(int* x, int l, int r);//双边扫描，快速排序
void quickSort2(int x[], int l, int r);//单边扫描，快速排序
void swap2(int &a,int &b); //交换，在MinGW上必须采用此方法，swap1无效
#define N 8 //数组的长度
int main() {
int* input = NULL;
input = (int*)malloc(N * sizeof(int));
if(input == NULL){
cout<<"内存溢出"<<endl;
}
for(int i = 0; i < N; i++){
input[i] = rand();
}
// int input[] = {55, 41, 59, 26, 53, 58, 97, 93};
cout<<"原始数据:"<<endl;
printArray(input, N);
quickSort2(input, 0, N-1);
printArray(input, N);
return 0;
}
void swap1(int a, int b){
int temp = a;
a = b;
b = temp;
}
void printArray(int * in, int n){
if(in == NULL){
return;
}
for(int i = 0; i<n; i++){
cout<<" "<<in[i];
}
cout<<endl;
}
void quickSort1(int* x, int l, int r){
if(l < r){
int i = l, j = r, key = x[l];
while(i < j){
while( i < j && x[j] >= key){
j--;
}
if(i < j){
x[i++] = x[j];
}
while(i < j && x[i] <= key){
i++;
}
if(i < j){
x[j--] = x[i];
}
}
cout<<"i = " <<i<<" j = "<<j<<endl;
x[i] = key;
quickSort1(x, l, i-1);
quickSort1(x, i+1, r);
}
}
void quickSort2(int x[], int l, int r){
if(l >= r)
return;
int m = l;
for(int i = l + l; i <= r; i++ ){
if(x[i] < x[l]){
swap2(x[++m], x[i]);
}
}
swap2(x[l], x[m]);
quickSort2(x, l, m - 1);
quickSort2(x, m + 1, r);
}
void swap2(int &a,int &b){
if(a==b) return;//对同一地址的数据交换，会使其结果为0
a=a^b;
b=a^b;
a=a^b;
}算法整理(二)---快速排序的两种实现方式:双边扫描和单边扫描,布布扣,bubuko.com
算法整理(二)---快速排序的两种实现方式:双边扫描和单边扫描
标签：快速排序
原文地址：http://blog.csdn.net/yanzi1225627/article/details/36045001
