快速排序(QuickSort)的C#实现(采用随机化主元方式)

算法代码如下：

/// <summary>
/// 快速排序的分隔，即:对于一个指定的主元x,找到位置i,使得i的左边元素都小于等于x,右边都大于等于x.
/// </summary>
/// <param name="A"></param>
/// <param name="p"></param>
/// <param name="q"></param>
/// <returns></returns>
private int QuickSortPartion(int[] A, int p, int q)
{

int theCount = q - p + 1;
//只有一个元素的情况，返回-1表示不用继续分割
if (theCount==1)
{

return -1;
}
//如果元素为2，则不用继续分割，只需要简单处理即可，这可以节省一些时间，但不是必须.
if (theCount == 2)
{
if (A[p] > A[q])
{
int tmp = A[p];
A[p] = A[q];
A[q] = tmp;
}
return -1;
}
//随机获取主元
Random theR=new Random(10);
int theMasterIndex = theR.Next(1, theCount);
int theMasterP = p + theMasterIndex -1;
//找到主元x,并与下界元素交换。
int theX = A[theMasterP];
A[theMasterP] = A[p];
A[p] = theX;
//寻找i,使得小于i位置的元素都小于等于thex,大于i位置的元素都大于thex.i初始位置为p.
int i = p;
//j初始位置为i+1;
for(int j=p+1;j<=q;j++)
{
//如果A[j]小于等于主元，则主元位置i右移一位，A[i]与A[j]交换
if (A[j] <= theX)
{
i++;
int theTmp = A[j];
A[j] = A[i];
A[i] = theTmp;
}
}
//做一次交换，将主元放到位置i.
A[p] = A[i];
A[i] = theX;
return i;
}
/// <summary>
/// 快速排序,主函数.
/// </summary>
/// <param name="A"></param>
/// <param name="S"></param>
/// <param name="E"></param>
private void QuickSort(int[] A, int S, int E)
{
//先找划分位置i
int theDivI = QuickSortPartion(A, S, E);
//不需要划分
if (theDivI < 0)
{
return;
}
int theP1_S = S, theP1_E = theDivI - 1;
int theP2_S = theDivI + 1, theP2_E = E;
//对左边递归快排
if (theP1_E >= S)
{
QuickSort(A, theP1_S, theP1_E);

}
//对右边递归快排.
if (theP2_S <= theP2_E)
{
QuickSort(A, theP2_S, theP2_E);
}
}

分治策略三步曲是：分，治，合。快排和归并排序同样采用的是分治策略，而且分治后的策略分支树都为2，但快排的优势在于，它不需要“合”，而归并排序的两个分支策略完成后，还有一个归并的过程。所以时间复杂度上归并显然不如快排。快排可以达到时间复杂度θ(n*lg(n)),归并的是θ(n*lg(n)).但快排的实际时间复杂度与其实现和输入都有关，最坏的情况，快排的时间复杂度也会达到θ(n^2),这个方面，归并排序的时间复杂度要均衡一些，与输入序列相关性不大。