算法笔记(选择算法）

包括，选择最大值，最小值，选择第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    }

 

后记：上述线性期望的选择算法是否可以改造成可适用有重复元素的情况，我感觉是比较困难，采用先排序再处理，增加的也是线性时间，只要排序算法是线性的，也可以达到线性选择。其实比较好的做法就是数据开始就是排序的，每次删除和增加都保持排序，虽然慢点，但由于这种操作比较少，而查询很频繁的情况下还是很好的。BigTable等其实都是这样做的.