一 演算法描述

       選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理是每一次從待排序的資料元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的資料元素排完。

       二 演算法實現（C#）

       1 用於整數陣列的升序排序

        public static void SelectionSort(int[] array)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                int minValueIndex = i;
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[minValueIndex] > array[j])
                    {
                        minValueIndex = j;
                    }
                }

                if (minValueIndex != i)
                {
                    Exchange(ref array[i], ref array[minValueIndex]);
                }
            }
        }
 

       2 用於整數陣列的降序排列

        public static void SelectionDesSort(int[] array)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                int maxValueIndex = i;
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[maxValueIndex] < array[j])
                    {
                        maxValueIndex = j;
                    }
                }

                if (maxValueIndex != i)
                {
                    Exchange(ref array[i], ref array[maxValueIndex]);
                }
            }
        }
 

       3 泛型版本

        public static void SelectionSort<T>(T[] array, Comparison<T> comparison)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                int extremumIndex = i;
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (comparison(array[extremumIndex], array[j]) > 0)
                    {
                        extremumIndex = j;
                    }
                }

                if (extremumIndex != i)
                {
                    Exchange<T>(ref array[i], ref array[extremumIndex]);
                }
            }
        }
 

       輔助方法

        private static void Exchange(ref int x, ref int y)
        {
            int temp = x;
            x = y;
            y = temp;
        }

        private static void Exchange<T>(ref T x, ref T y)
        {
            T temp = x;
            x = y;
            y = temp;
        }

       三 演算法分析

       1  無論初始陣列的順序是怎樣的，每一次從待排序陣列中選取最小（大）值時，都需要遍歷比較待排序陣列的所有元素，所以選擇排序演算法的最佳和最壞情況的時間複雜度都是O(n^2)。

       2 選擇排序演算法是一種原址排序演算法。在整個排序過程中只需要常數個元素儲存在陣列之外，即空間複雜度為O(1)。

       3 選擇排序演算法是不穩定的。例如，若對陣列 3,3,2使用選擇排序演算法進行升序排序，則當3 與 2交換位置時，會導致兩個3的位置顛倒。

       四 執行結果

       在選擇排序演算法中，影響演算法執行時間的主要因素為每次查詢未排序陣列中最小（大）值的內層迴圈的執行次數。而內層迴圈的執行次數可以根據當前最小（大）值與未排序元素的比較次數來估算（此處內層迴圈的執行次數大約為比較次數的2倍）。

       在演算法的泛型實現版本中，通過在委託傳入的比較方法里加入計數語句，則能很容易的得到比較語句執行的次數。

private static int AscComparison(int x, int y)  
{  
    <span style="color:#ff0000;">count++;</span>  
    if (x > y)  
    {  
        return 1;  
    }  
    else if (x == y)  
    {  
        return 0;  
    }  
    else  
    {  
        return -1;  
    }  
}

static void Main(string[] args)  
{  
    for (int i = 0; i < 10000; i++)  
    {  
        //在1-100內產生10個隨機數  
        int[] randomIntArray = DataCreator.CreateRandomIntArray(1, 100, 10);  
        Sort.SelectionSort(randomIntArray, AscComparison);  
        PrintAarry(randomIntArray);  
    }  
    int averageCount = count / 10000;  
    Console.WriteLine(averageCount);  
} 

       n = 10，  averageCount = 45 = 0.45* 10 ^2; 
       n = 100,   averageCount = 4950 = 0.5 * 100 ^ 2;
       n = 1000, averageCount = 499500 = 0.5 * 1000^2

       選擇排序演算法的平均執行時間複雜度也是θ(n^2)。

      另外，儘管都是時間複雜度為θ(n^2)的排序演算法，選擇排序演算法在輸入資料為任何情況下計算時間都幾乎相等，且與插入演算法在最壞情況下的計算時間相近，故而總體上插入排序演算法在計算時間上要優於選擇排序演算法。