快排的几种写法及时间对比

十行递归快排：

void Jin_QuickSort1(int *arr,int low,int high)
{
	if(low >= high)
		return ;
	int i = low ;
	for(int j = low ; j < high ;++j)
		if(arr[j] <= arr[high])
			swap(arr[j],arr[i++]);
	swap(arr[i],arr[high]);
	Jin_QuickSort1(arr,low,i-1);
	Jin_QuickSort1(arr,i+1,high);
}

二十行递归快排：

void Jin_QuickSort2(int *arr,int low,int high)
{
	if(low >= high)
		return ;
	int first = low ;
	int last = high ;
	int key = arr[low];
	while(first < last)
	{
		while(first < last && key <= arr[last])
			last--;
		arr[first] = arr[last];
		while(first < last && key >= arr[first])
			first++;
		arr[last] = arr[first];
	}
	arr[first] = key ;
	Jin_QuickSort2(arr,low,first-1);
	Jin_QuickSort2(arr,first+1,high);
}

栈实现非递归快排：

int Jin_Partition3(int *arr,int low,int high)
{
	int key = arr[low];
	while(low < high)
	{
		while(low < high && key <= arr[high])
			high--;
		arr[low] = arr[high];
		while(low < high && key >= arr[low])
			low++;
		arr[high] = arr[low];
	}
	arr[low] = key ;
	return low ;
}

void Jin_QuickSort3(int *arr,int low,int high)
{
	if(low >= high)
		return ;
	stack<int> s;
	s.push(low);
	s.push(high);
	while(!s.empty())
	{
		int j = s.top();
		s.pop();
		int i = s.top();
		s.pop();
		int k = Jin_Partition3(arr,i,j);
		if(k-1>i)
		{
			s.push(i);
			s.push(k-1);
		}
		if(k+1<j)
		{
			s.push(k+1);
			s.push(j);
		}
	}
}

排序耗时比较：

20w个随机数排序：

十行递归：330ms

二十行递归：38ms（最优）

非递归：683ms

100w个随机数排序：

十行递归：2764ms

二十行递归：213ms（最优）

非递归：3649ms