脚本宝典收集整理的这篇文章主要介绍了二分排序和冒泡排序的性能比较，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

对于数据量很大的情况，二分法排序相较于冒泡排序具有压倒性的性能优势

测试情况如下：

元素个数=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);
        }

 运行结果

脚本宝典总结

以上是脚本宝典为你收集整理的二分排序和冒泡排序的性能比较全部内容，希望文章能够帮你解决二分排序和冒泡排序的性能比较所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。