包括,选择最大值,最小值,选择第k大元素的算法。其中选择第k大元素包括随机选择算法和最坏线性时间算法。选择算法有一个假设就是输入的元素都不相同,如果是输入序列有重复的,那么这些算法都不适用。由于输入序列条件苛刻,因此实际应用中感觉很难用,还不如老老实实先排序,然后再遍历寻找。
下面是算法实现代码:
public class MySearchs
{
/// <summary>
/// 获取最大值和最小值.
/// </summary>
/// <param name="A"></param>
/// <param name="MaxV"></param>
/// <param name="MinV"></param>
public static void GetMaxAndMinValue(int[] A, out int MaxV, out int MinV)
{
MaxV = 0;
MinV = 0;
int theStart = 1;
if (A.Length % 2 == 0)
{
MaxV = A[0];
MinV = A[1];
theStart = 2;
}
else
{
MaxV = A[0];
MinV = A[0];
}
while (theStart + 1 < A.Length)
{
if (A[theStart] > A[theStart + 1])
{
if (A[theStart] > MaxV)
{
MaxV = A[theStart];
}
if (A[theStart + 1] < MinV)
{
MinV = A[theStart + 1];
}
}
else
{
if (A[theStart + 1] > MaxV)
{
MaxV = A[theStart + 1];
}
if (A[theStart] < MinV)
{
MinV = A[theStart];
}
}
theStart += 2;
}
}
#region 随机选择算法
/// <summary>
/// 随机选择算法:分区采用随机快排分区方法。寻找第i大元素.
/// 算法依赖:输入数组元素无重复.
/// </summary>
/// <param name="A">输入数组</param>
/// <param name="p">数组开始索引</param>
/// <param name="r">数组结束索引</param>
/// <param name="i">第i大元素</param>
/// <returns>第i大元素值</returns>
public static int RandomizeSelect(int[] A, int p, int r, int i)
{
if (p == r)
{
return A[p];
}
if (p > r)
{
return int.MinValue;
}
int q = RandomizePartion(A, p, r);
int k =q - p + 1;
if (i == k)
{
return A[q];
}
else if (i < k)
{
return RandomizeSelect(A, p, q - 1, i);
}
else
{
return RandomizeSelect(A, q + 1, r, i);
}
}
/// <summary>
/// 随机分区算法
/// </summary>
/// <param name="A">输入数组</param>
/// <param name="S">数组开始位置</param>
/// <param name="E">数组结束位置</param>
/// <returns>分区位置</returns>
private static int RandomizePartion(int[] A, int S, int E)
{
Random theR = new Random();
int theBaseIndex = theR.Next(1, E - S+1 );
SwapValue(A, E, S + theBaseIndex-1);
return Partion(A, S, E);
}
/// <summary>
/// 分区算法:和快排分区算法一样
/// </summary>
/// <param name="A">要分区的数组</param>
/// <param name="S">要分区数组起始位置</param>
/// <param name="E">要分区数组结束位置</param>
/// <returns>分区索引</returns>
private static int Partion(int[] A, int S, int E)
{
int theX = A[E];
int i = S - 1;
for (int j = S; j < E; j++)
{
if (A[j] <= theX)
{
i++;
SwapValue(A, i, j);
}
}
SwapValue(A, i + 1, E);
return (i + 1);
}
#endregion
private static void SwapValue(int[] A, int i, int j)
{
int theTmp = A[i];
A[i] = A[j];
A[j] = theTmp;
}
#region 分组选择算法
/// <summary>
/// 分组元素数目
/// </summary>
private const int groupNum = 5;
/// <summary>
/// 分组组内中位索引.
/// </summary>
private const int groupMid = 3;
/// <summary>
/// 选择分区算法,这里采用的分区主元素是传入的参数.
/// </summary>
/// <param name="A">待分区数组</param>
/// <param name="p">待分区数组起始位置</param>
/// <param name="r">待分区数组结束位置</param>
/// <param name="x">主元素值</param>
/// <returns>分区索引</returns>
private static int SelectPartion(int[] A, int p, int r, int x)
{
int i, j;
//i从前往后搜索比x大的元素,j从后往前搜索比j小的元素.
for (i = p, j = r; i < j; i++)
{
//如果找到比x大的元素,就停下来寻找可交换的位置.
if (A[i] > x)
{
//从后向前搜索,找到第1个x小的位置
while (i < j && A[j] > x)
{
j--;
}
//如果i!=j则交换i,j的值.
if (i != j)
{
SwapValue(A, i, j);
j--;
}
}
}
return i - 1;
}
/// <summary>
/// 选择第k大元素,采用分组中位之中位数为分区主元素方法.
/// 算法依赖:输入数组元素无重复.
/// </summary>
/// <param name="A">输入数组</param>
/// <param name="p">输入数组起始位置</param>
/// <param name="r">输入数组结束位置</param>
/// <param name="k">第k大元素</param>
/// <returns>第k大元素</returns>
public static int SelectByGroup(int[] A, int p, int r, int k)
{
//如果元素少于分组数目,则直接插入排序,取第k大元素.
//注意这里第k大如果不存在,则返回最大元素.
if (r - p < groupNum)
{
InsertSort(A, p, r);
if (p + k - 1 <= r)
{
return A[p + k - 1];
}
else
{
return A[r];
}
}
//当前处理的子数组元素个数
int theElementNum = r - p + 1;
//组数,注意这里的除法是整除,采用的截断尾数方式.
int theGroups = theElementNum / groupNum;//组数,如果不是整除,最后一组忽略.
//对每组进行插入排序,取每组的中位数,并交换到从p开始的位置
//处理完成后从p开始的thGroups个元素就是前面每组的中位数.
for (int i = 0; i < theGroups; i++)
{
int s = p + groupNum * i, t = s + groupNum - 1;
InsertSort(A, s, t);
SwapValue(A, p + i, s + groupMid -1);
}
//中位序号,后面的算法将选择前面分组得来的中位数里的中位数.
int theGroupMid = theGroups / 2;
if (theGroups % 2 != 0)
{
theGroupMid++;
}
//选择分组得来的中位数的中位数,将作为分区的主元素.
int x = SelectByGroup(A, p, p + theGroups - 1, theGroupMid);
//以分组中位数的中位数作为主元素来分区.
int theIndex = SelectPartion(A,p, r, x);
int j = theIndex - p + 1;
//如果k<=j则第k大元素在低分区,否则,在高分区.注意在高分区,则第k大需变成寻找第k-j大,
//这是跟随机选择算法一个非常不同的地方.
if (k <= j)
return SelectByGroup(A, p, theIndex, k);
else
return SelectByGroup(A, theIndex + 1, r, k - j);
}
/// <summary>
/// 插入排序
/// </summary>
/// <param name="A">需排序的数组</param>
/// <param name="s">需排序的数组开始元素位置</param>
/// <param name="e">需排序的数组结束元素位置</param>
private static void InsertSort(int[] A, int s, int e)
{
//从第2个开始,将当前数插入到0..i-1数组中去.
for (int i = s+1; i <= e; i++)
{
int theCurrVal = A[i];
int j = i - 1;
//找到插入位置,并后移元素.
while (j >= s && theCurrVal < A[j])
{
A[j + 1] = A[j];
j--;
}
A[j + 1] = theCurrVal;
}
}
#endregion
}