算法笔记(选择算法）

包括，选择最大值，最小值，选择第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等其实都是这样做的.