c#之冒泡排序的三種實現和性能分析

     冒泡排序算法是我們經常見到的尤其是子一些筆試題中.

     下面和大家討論c#中的冒泡排序，筆者提供了三種解決方案,並且會分析各自的性能優劣.

    第一種估計大家都掌握的，使用數據交換來實現，這種就不多說了，園子里的各位前輩分析的都很好,搜一下就有很多.

    簡單貼一下代碼：

     

 //定義數組
 static int[] nums = new int[] { 100, 99, 45, 56, 67, 78, 98, 8, 7, 65, 55, 43, 32, 23, 35, 36, 38, 37, 120, 150, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 30, 32, 31, 29, 28, 26, 27, 25, 22, 24 };
        static void Main(string[] args)
        {
            Console.WriteLine("冒泡排序之傳統方法");
            BubblingOne();
            Console.ReadKey();
        }
/// <summary>
        /// 冒泡排序,傳統數據交換實現
        /// </summary>
        static void BubblingOne()
        {
            //定義一個需要排序的數組

            //定義一個臨時變量用於數據交換
            int temp; //臨時變量，保存最大值
            int i, j; //循環變量
            for (i = 0; i < nums.Length - 1; i++)
            {
                for (j = 0; j < nums.Length - 1 - i; j++)
                {
                    if (nums[j] < nums[j + 1])
                    {
                        temp = nums[j];
                        nums[j] = nums[j + 1];
                        nums[j + 1] = temp;
                    }
                }
            }
            foreach (int c in nums) //用foreach輸出排序后的數組元素 
            {
                Console.Write(c + "\t");
            }
        }

運行結果如下：

  

接下來我們介紹第二種實現方法：Linq的查詢表達式語法的實現.

 

  關於Linq的介紹請參見：

 

 

  /// <summary>
        /// linq 冒泡排序算法
        /// </summary>
        static void BubblingTwo()
        {    
            IEnumerable<int> num = from a in nums orderby a descending select a;
            foreach (int item in num)
            {
                Console.Write(item + "\t");
            }   
        }

 

請注意我們實現了泛型接口IEnumerable<T>

IEnumerable<T> 是一個接口，通過該接口，可以使用 foreach 語句來枚舉泛型集合類。 泛型集合類支持 IEnumerable<T>，就像非泛型集合類（如ArrayList）支持 IEnumerable。

 

 

運行結果和第一種方法一致.

 你可能已經發現了,代碼簡潔了許多,有原來的8行縮短為一行,這不正是我們的追求嗎？尤其是在面試的時候是否為你節約了大量的時間？

那是否還有其他的方式繼續實現冒泡排序呢？答案是肯定的，記住我們是對數組中的數據進行操作，Linq有兩個擴展方法OrderByDescending和OrderBy用於對數據排序,請參見：對數據進行排序

第三種實現：使用Linq 的擴展方法OrderByDescending(倒序排列)和OrderBy(正序排列)

 

  /// <summary>
        /// 使用Linq的擴展方法OrderByDescending
        /// </summary>
        static void BubblingThree()
        {
            IEnumerable<int> num = nums.OrderByDescending(a => a);
            foreach (int item in num)
            {
                Console.Write(item + "\t");
            }
        }

代碼一如既往的簡潔.請注意該方式實現了IEnumerable<T>接口.

 也許還有更多的實現方式,但本文只介紹這三種方法.

 既然有這么多實現方法,我們應該怎么選擇用哪種呢，筆者在這里做了一個簡單的性能對比(比較各自的執行時間).

首先我們更新以上代碼,加入時間的計算：

  

 在為三種方法加入了上圖紅色區域代碼后，我們比較一下不同數據量三種方法各自的表現

 插入5條數據

       //5條數據
        static int[] nums = new int[] { 10, 99, 45, 56, 67 };

 結果如下：

 

 從上圖我們可以簡單得出結論,在小數據量是Linq的查詢表達式語法表現最差,使用OrderByDescending方法最佳.

 下面我們多加幾條數據.

  //15條數據
        static int[] nums = new int[] { 100, 99, 45, 56, 67, 78, 98, 8, 7, 65, 55, 43, 38, 37, 120 };

結果如下：

  

結果還是OrderByDescending方法領先

 

我們繼續加入數據： 

   //50條數據
        static int[] nums = new int[] { 101, 991, 451, 561, 100, 99, 45, 56, 67, 78, 98, 8, 7, 65, 55, 43, 32, 23, 35, 36, 38, 37, 120, 150, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 30, 32, 31, 29, 28, 26, 27, 25, 22, 24 };
       

結果如下：

 

從上圖中我們可以看到情況發生了變化,第一種方法領先,然而在我們的測試中絲毫沒有看到Linq查詢表達式語法(感謝@WAKU的批評)的優勢,但對於Linq中的擴展方法OrderByDescing()卻有不俗的表現;

以上介紹了在C#下的三種冒泡排序方法以及性能分析.由於數據量較小得出結論難免沒有說服力,有興趣的朋友可已多加數據至數萬條。

如果對你有幫助，請幫忙推薦一下.