包括，选择最大值，最小值，选择第k大元素的算法。其中选择第k大元素包括随机选择算法和最坏线性时间算法。选择算法有一个假设就是输入的元素都不相同，如果是输入序列有重复的，那么这些算法都不适用。由于输入序列条件苛刻，因此实际应用中感觉很难用，还不如老老实实先排序，然后再遍历寻找。
下面是算法实现代码：
public class MySearchs { ///
/// 获取最大值和最小值. /// ///
///
///
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 随机选择算法 ///
/// 随机选择算法：分区采用随机快排分区方法。寻找第i大元素. /// 算法依赖：输入数组元素无重复. /// ///
输入数组 ///
数组开始索引 ///
数组结束索引 ///
第i大元素 ///
第i大元素值 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); } } ///
/// 随机分区算法 /// ///
输入数组 ///
数组开始位置 ///
数组结束位置 ///
分区位置 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); } ///
/// 分区算法：和快排分区算法一样 /// ///
要分区的数组 ///
要分区数组起始位置 ///
要分区数组结束位置 ///
分区索引 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 分组选择算法 ///
/// 分组元素数目 /// private const int groupNum = 5; ///
/// 分组组内中位索引. /// private const int groupMid = 3; ///
/// 选择分区算法，这里采用的分区主元素是传入的参数. /// ///
待分区数组 ///
待分区数组起始位置 ///
待分区数组结束位置 ///
主元素值 ///
分区索引 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; } ///
/// 选择第k大元素，采用分组中位之中位数为分区主元素方法. /// 算法依赖：输入数组元素无重复. /// ///
输入数组 ///
输入数组起始位置 ///
输入数组结束位置 ///
第k大元素 ///
第k大元素 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); } ///
/// 插入排序 /// ///
需排序的数组 ///
需排序的数组开始元素位置 ///
需排序的数组结束元素位置 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 }
后记：上述线性期望的选择算法是否可以改造成可适用有重复元素的情况，我感觉是比较困难，采用先排序再处理，增加的也是线性时间，只要排序算法是线性的，也可以达到线性选择。其实比较好的做法就是数据开始就是排序的，每次删除和增加都保持排序，虽然慢点，但由于这种操作比较少，而查询很频繁的情况下还是很好的。BigTable等其实都是这样做的.
