算法实践系列--查找第K大值

下面的算法实现基于随机化快排，有一个前提是需要假设所有的元素都不相等，否则算法不成立。下面是具体实现：

1）随机划分算法与快排一样：

/// <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)
{
count2++;
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;
int i = p;
//寻找i,使得小于i位置的元素都小于等于thex,大于i位置的元素都大于thex.
for(int j=p+1;j<=q;j++)
{
if (A[j] <= theX)
{
i++;
int theTmp = A[j];
A[j] = A[i];
A[i] = theTmp;
}
count2++;
}
//将主元放到位置i.
A[p] = A[i];
A[i] = theX;
return i;
}

2）查找算法，与快排类似：

/// <summary>
/// 寻找序列中第K大的值.
/// </summary>
/// <param name="A">序列</param>
/// <param name="S">序列开始位置</param>
/// <param name="E">序列结束位置</param>
/// <param name="K">查找结果条件</param>
private int FindNOKValue(int[] A, int S, int E,int K)
{
count2++;
//先找划分位置i
int theDivI = QuickSortPartion(A, S, E);
//不需要划分,也表示没找到.
if (theDivI < 0)
{
return -1;
}
//查找跟快排的区别就是每次只需要进入一个分支。
//如果划分位置刚好是K,就表示第K大值找到.
if (theDivI == K)
{
return A[K];
}
//如果查找划分位置大于K,则进入小的划分，否则进入大的划分.
if (theDivI > K)
{
int theP1_S = S, theP1_E = theDivI - 1;
//对左边递归快排
if (theP1_E >= S)
{
return FindNOKValue(A, theP1_S, theP1_E,K);

}
}
else
{
int theP2_S = theDivI + 1, theP2_E = E;
//对右边递归快排.
if (theP2_S <= theP2_E)
{
return FindNOKValue(A, theP2_S, theP2_E,K);
}
}
return -1;
}