首先简单谈下高速排序的特点，时间复杂度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;
}

单边扫描的特点:

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;
}