對於資料量很大的情況，二分法排序相較於氣泡排序具有壓倒性的效能優勢

測試情況如下：

元素個數=200000,二分排序所用時間=13616743(Ticks)  1.3秒

元素個數=200000,氣泡排序所用時間=325，724，1227(Ticks) 325秒

氣泡排序與二分排序時間之比為=239.208541058607        

元素個數=100000,氣泡排序所用時間=811352144(Ticks)  81秒

元素個數=100000,二分排序所用時間=3274058(Ticks)  0.3秒

氣泡排序與二分排序時間之比為=247.812391839118

元素個數=10000,氣泡排序所用時間=8774623(Ticks)

元素個數=10000,二分排序所用時間=87368(Ticks)

氣泡排序與二分排序時間之比為=100.432915941764

元素個數=1000,氣泡排序所用時間=81145

元素個數=1000,二分排序所用時間=9128

氣泡排序與二分排序時間之比為=8.8896801051709

元素個數=100,二分排序所用時間=3860(Ticks)

元素個數=100,氣泡排序所用時間=6095(Ticks)

氣泡排序與二分排序時間之比為=1.57901554404145

二分查詢方法

//降序排序集合的二分查詢，返回值為應該插入的索引值
        public static  int BinarySearch(List<int> list, int value, int low, int high)
        {
            if (list.Count==0) return 0;
            int middle = (low + high) / 2;

            if (high ==low+ 1)
            {
                if (value <= list[high]) return high + 1;
                else if (value <= list[low]) return low + 1;
                else return low;
            }
            else if (high == low )
            {
                if (value <= list[high]) return high + 1;
                else return high;
            }
            else
            {
                if (value > list[middle]) return BinarySearch(list, value, low, middle);
                else return BinarySearch(list, value, middle, high);
            }
        }
 

排序方法

//二分排序-降序
        static List<int> BinarySort(List<int > list)
        {
            List<int> result = new List<int>();
            int insertPos;
            for (int i = 0; i < list.Count; i++)
            {
                insertPos = BinarySearch(result, list[i], 0, result.Count - 1);
                if (insertPos >= result.Count) result.Add(list[i]);
                else result.Insert(insertPos, list[i]);
            }
            return result;
        }
        //氣泡排序-降序
        static List<int> BubbleSort(List<int> list)
        {
            List<int> list2 = new List<int>(list);
            int temp;
            for (int i = 0; i < list2.Count; i++)
            {
                for (int j = i+1; j < list2.Count; j++)
                {
                    if (list2[i] < list2[j])
                    {
                        temp = list2[i];
                        list2[i] = list2[j];
                        list2[j] = temp;
                    }
                }
            }
            return list2;
        }
 

測試方法

//二分排序和氣泡排序執行時間測試
        static void test4()
        {
            
            List<int> list = new List<int>();
            Random r = new Random();
            for (int i = 0; i < 100; i++)
            {
                list.Add(r.Next(0, 100000000));
            }
            //二分排序
            Stopwatch watch2 = new Stopwatch();
            watch2.Start();
            List<int> list2 = BinarySort(list);
            watch2.Stop();
            Console.WriteLine($"元素個數={list.Count},二分排序所用時間={watch2.ElapsedTicks}(Ticks)");
            //氣泡排序
            Stopwatch watch1 = new Stopwatch();
            watch1.Start();
            List<int> list1 = BubbleSort(list);
            watch1.Stop();
            Console.WriteLine($"元素個數={list.Count},氣泡排序所用時間={watch1.ElapsedTicks}(Ticks)");

          

            double ratio = (double)watch1.ElapsedTicks / (double)watch2.ElapsedTicks;
            Console.WriteLine($"氣泡排序與二分排序時間之比為={ratio}");
            //DisplayList(list);
            //DisplayList(list1);
            //DisplayList(list);
            //DisplayList(list2);
        }

 執行結果