一 演算法描述

       插入排序是一種針對少量元素的有效的排序演算法。其基本操作是將一個數據插入到已經排好序的有序資料中，從而得到一個新的、個數加一的有序資料。在《演算法導論》一書中，作者以人們常用的排序撲克牌的例子來說明此演算法：

       “開始時，我們的左手為空並且桌子上的牌面向下。然後,我們毎次從桌子上拿走一張牌並將它插入左手中正確的位置。為了找到一張牌的正確位置，我們從右到左將它與已在手中的每張牌進行比較。拿在左手上的牌總是排序好的。”

       （圖片擷取自《演算法導論》）

       二 演算法實現（c#）

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

        public static void InsertionSort(int[] array)
        {
            if (array == null || array.Length < 2)
            {
                return;
            }

            int key;
            for (int i = 1; i < array.Length; i++)
            {
                key = array[i];
                int j = i - 1;
                while (j >= 0 && key < array[j])
                {
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = key;
            }
        }
 

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

        public static void InsertionDesSort(int[] array)
        {
            if (array == null || array.Length < 2)
            {
                return;
            }

            int key;
            for (int i = 1; i < array.Length; i++)
            {
                key = array[i];
                int j = i - 1;
                while (j >= 0 && key > array[j])
                {
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = key;
            }
        }
 

        public static void InsertionSort<T>(T[] array, Comparison<T> comparison)
        {
            if (array == null || array.Length < 2)
            {
                return;
            }

            T key;
            for (int i = 1; i < array.Length; i++)
            {
                key = array[i];
                int j = i - 1;
                while (j >= 0 && comparison(array[j], key) > 0)
                {
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = key;
            }
            return;
        }

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

       2 插入排序是穩定的。具有相同值的元素在輸出陣列中的相對次序與其在輸入陣列中的相對次序相同。

       3 若輸入陣列已經排好序，則演算法執行時間未最佳情況，此時的時間複雜度是O(n)；若輸入陣列已反向排序，則演算法的執行時間未最壞情況，此時的時間複雜度為O(n^2).

       四 執行結果

       在插入排序演算法中，影響演算法執行時間的主要因素為內層while迴圈的執行次數。而內層迴圈的執行次數，則可以根據array[j]與key的比較次數來大致估算（此處內層迴圈執行的語句的數量約為比較次數的4倍）。因此，如果我們得到了比較語句的執行次數，則可以大致瞭解到整個演算法的執行規模。

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

        private static int AscComparison(int x, int y)
        {
            count++;
            if (x > y)
            {
                return 1;
            }
            else if (x == y)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }

       為了測試該演算法的平均執行情況，通過對10000個隨機陣列進行排序取平均：

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

       測試結果：

       n = 10，  averageCount = 29 = 0.29 * 10 ^2;

       n = 100,   averageCount = 2567 = 0.2567 * 100 ^ 2;

       n = 1000, averageCount = 250724 = 0.250724 * 1000^2

       由此可得，插入排序演算法的平均執行時間複雜度也是θ(n^2).