快速排序（c++）

代码实现：

#include<iostream>
using namespace std;

int Partition(int a[],int low,int high){
	int i=low,j=high,pivot=a[low];
	while(i<j){
		while(i<j&&a[j]>=pivot){//从右往左扫描 
			j--;
		}
		if(i<j){
			swap(a[j],a[i++]);//交换a[i],a[j]后，i+1开始从左往右扫描 
		}
		while(i<j&&a[i]<=pivot){
			i++;
		}
		if(i<j){
			swap(a[i],a[j--]);
		}
	}
	return i;
}

void quickSort(int a[],int low,int high){
	if(low<high){
		int mid=Partition(a,low,high);
		quickSort(a,low,mid-1);
		quickSort(a,mid+1,high);
	}	
}

int main(){
	int n;
	cin>>n;
	int *a=new int[n];
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	quickSort(a,0,n-1);
	for(int i=0;i<n;i++){
		cout<<a[i]<<"	";
	}
	return 0;
} 

最好情况：

时间复杂度：
n=1,T(n)=O(1);
n>1,
T(n)=2T(n/2)+O(n) //扫描一次全数组确定pivot的最终位置，与此同时划分出两个规模为n/2的子问题（理想情况）=2[2T(n/4)+O(n/2)]+O(n)=4T(n/4)+2O(n)=8T(n/8)+3O(n)=…=2^xT(n/2^x)+xO(n)

令n=2^x，T(n)=O(nlogn)。

空间复杂度：想象一下满二叉树 O（logn）。

最坏情况：

时间复杂度：
n=1,T(n)=1;
n>1,T(n)=T(n-1)+O(n)=T(n-2)+O(n-1)+O(n)=…=T(1)+O(2)+O(3)+…+O(n)=O(n(n+1)/2)近似O(n²)。

空间复杂度：想象一下只有左子树或者只有右子树的二叉树O(n)。

优化策略：

最初算法是每次向左扫描，找到一个大于pivot的元素就交换一次；每次向右扫描，找到一个小于pivot的元素就交换一次。
为了减少元素交换的次数，我们可以等同时从左找到大于pivot的数和从右找到小于pivot的数，再进行一次交换。直到i,j相遇 相遇节点前的数都比pivot小，相遇节点后的数都比pivot大。 判断相遇节点与pivot之间大小来确定基准元素位置。

int Partition2(int a[],int low,int high){
	int i=low,j=high,pivot=a[low];
	while(i<j){
		while(i<j&&a[j]>=pivot){//从右往左扫描 j右边的元素（也就是j扫描过的元素）是比基准元素大的
			j--;
		}
		while(i<j&&a[i]<=pivot){//从左往右扫描 i左边的元素（也就是i扫描过的元素）是比基准元素小的
			i++;
		}
		if(i<j){
			swap(a[i++],a[j--]);
		}
	}
	
	//i,j相遇 相遇节点前都是比pivot小，相遇节点后都是比pivot大 
	if(a[i]>pivot){//相遇节点比pivot大 不能放在前面 
		swap(a[i-1],a[low]);
		return i-1; 
	} 
	swap(a[i],a[low]);
	return i;
}