線性時間選擇算法

在一個由 n 個元素組成的集合中，第 i 個順序統計量（order statistic）是該集合中第 i 小的元素。也就是說，最小值是第 1 個順序統計量（i = 1），最大值是第 n 個順序統計量（i = n）。

中位數（median）是它所在集合的中點元素。當 n 為奇數時，中位數是唯一的，出現在 i = (n + 1)/2 處。當 n 為偶數時，存在兩個中位數，下中位數 i = n/2 和上中位數 i = n/2 + 1 處。因此，不考慮 n 的奇偶性，中位數總是出現在 i = (n+1)/2 的中位數處。本文中所用的中位數總是指下中位數。

• 選擇最大值和最小值
• 選擇中位數或任意位置值

選擇最大值和最小值

對於確定最大值和最小值的問題，n-1 次比較是最優的。

對於同時獲取最大值和最小值，至多需要 3(n/2) 次比較就足以同時找到。如果 n 是奇數，那么總共需要 3(n/2) 次比較。如果 n 是偶數，則可先做一次初始比較，接着做 3((n - 2)/2) 次比較。

  class Program
  {
    static void Main(string[] args)
    {
      int[] unsorted = 
        { 
          4, 1, 5, 2, 6, 3, 7, 9, 8, 0 
        };

      Console.WriteLine("Min: {0}", GetMinimum(unsorted));
      Console.WriteLine("Max: {0}", GetMaximum(unsorted));

      int min, max;
      GetBothMinMax(unsorted, out min, out max);
      Console.WriteLine("Min: {0}, Max: {1}", min, max);

      Console.Read();
    }

    static int GetMinimum(int[] a)
    {
      int min = a[0];

      // n-1 次比較
      for (int i = 1; i < a.Length; i++)
      {
        if (a[i] < min)
          min = a[i];
      }

      return min;
    }

    static int GetMaximum(int[] a)
    {
      int max = a[0];

      // n-1 次比較
      for (int i = 1; i < a.Length; i++)
      {
        if (a[i] > max)
          max = a[i];
      }

      return max;
    }

    static void GetBothMinMax(int[] a, out int min, out int max)
    {
      min = a[0];
      max = a[0];

      if (a.Length % 2 > 0) // n 為奇數
      {
        for (int i = 1; i < a.Length; i = i + 2)
        {
          if (a[i] < a[i + 1])
          {
            if (a[i] < min) min = a[i];
            if (a[i + 1] > max) max = a[i + 1];
          }
          else
          {
            if (a[i + 1] < min) min = a[i + 1];
            if (a[i] > max) max = a[i];
          }
        }
      }
      else                  // n 為偶數
      {
        for (int i = 1; i < a.Length - 1; i = i + 2)
        {
          if (a[i] < a[i + 1])
          {
            if (a[i] < min) min = a[i];
            if (a[i + 1] > max) max = a[i + 1];
          }
          else
          {
            if (a[i + 1] < min) min = a[i + 1];
            if (a[i] > max) max = a[i];
          }
        }

        if (a[a.Length - 1] < min) min = a[a.Length - 1];
        if (a[a.Length - 1] > max) max = a[a.Length - 1];
      }
    }
  }

選擇中位數或任意位置值

RANDOMIZED-SELECT 算法采用快速排序算法的思想。區別是，快速排序會遞歸地處理划分的兩邊，而 RANDOMIZED-SELECT 則只處理一邊。所以快速排序的期望運行時間是 Θ(n lg n)，而 RANDOMIZED-SELECT 的期望運行時間為 Θ(n)。

RANDOMIZED-SELECT 的最壞運行時間為 Θ(n²)，即使是要選擇最小元素也是如此。因為它是隨機化的，該算法的平均情況性能較好。

  public class QuickFindAlgorithm
  {
    public static void TestRandomizedQuickFind()
    {
      int[] unsorted = 
        { 
          4, 1, 5, 2, 6, 3, 7, 9, 8, 0 
        };

      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 1));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 2));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 3));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 4));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 5));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 6));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 7));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 8));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 9));
      Console.WriteLine("Find Value : {0}",
        RandomizedQuickFind(unsorted, 0, unsorted.Length - 1, 10));

      int median = RandomizedQuickFind(unsorted, 
        0, unsorted.Length - 1, (unsorted.Length + 1) / 2);
      Console.WriteLine("Find Median : {0}", median);

      Console.Read();
    }

    static int RandomizedQuickFind(int[] a, int p, int r, int i)
    {
      if (p == r)
        return a[p];

      int q = RandomizedPartition(a, p, r);
      int k = q - p + 1;

      if (i == k)     // the pivot value is the answer
      {
        return a[q];
      }
      else if (i < k) // i is in left side
      {
        return RandomizedQuickFind(a, p, q - 1, i);
      }
      else            // i is in right side
      {
        return RandomizedQuickFind(a, q + 1, r, i - k);
      }
    }

    static void RandomizedQuickSort(int[] unsorted, int left, int right)
    {
      if (!(left < right)) return;

      int pivotIndex = RandomizedPartition(unsorted, left, right);

      RandomizedQuickSort(unsorted, left, pivotIndex - 1);
      RandomizedQuickSort(unsorted, pivotIndex + 1, right);
    }

    static int RandomizedPartition(int[] unsorted, int left, int right)
    {
      int i = random.Next(left, right);
      Swap(unsorted, i, right);
      return Partition(unsorted, left, right);
    }

    static int Partition(int[] unsorted, int left, int right)
    {
      int pivotIndex = right;

      // 哨兵
      int sentinel = unsorted[right];

      // 子數組長度為 right - left + 1
      int i = left - 1;
      for (int j = left; j <= right - 1; j++)
      {
        if (unsorted[j] <= sentinel)
        {
          i++;
          Swap(unsorted, i, j);
        }
      }

      Swap(unsorted, i + 1, pivotIndex);

      return i + 1;
    }

    static void Swap(int[] unsorted, int i, int j)
    {
      int temp = unsorted[i];
      unsorted[i] = unsorted[j];
      unsorted[j] = temp;
    }

    static Random random = new Random(new Guid().GetHashCode());
  }

本篇文章《線性時間選擇算法》由 Dennis Gao 發表自博客園，任何未經作者同意的爬蟲或人為轉載均為耍流氓。