转：JavaScript排序性能比较

最新推荐文章于 2024-03-30 09:57:57 发布

so_fast

最新推荐文章于 2024-03-30 09:57:57 发布

阅读量135

点赞数

分类专栏： JavaScript 文章标签： php photoshop c/c++

本文链接：https://blog.csdn.net/so_fast/article/details/84481745

版权

JavaScript 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

http://www.nowamagic.net/javascript/js_SortEffectiveInJavascript.php

JavaScript排序性能比较

2011-02-15

排序是经常使用的编程例子，在JavaScript里各种排序的性能又如何呢？每个浏览器测试得出的数据会不一样。比如我用chrome 测试一般快速排序都会最快，IE 则根据数组长度有可能希尔最快。

不要用太大数据去测试冒泡排序(浏览器崩溃了我不管)。

[quickSort]: 0,1,2,3,4,5,6,7,8,9

[insertSort]: 0,1,2,3,4,5,6,7,8,9

[shellSort]: 0,1,2,3,4,5,6,7,8,9

[systemSort]: 0,1,2,3,4,5,6,7,8,9

[bubbleSort]: 0,1,2,3,4,5,6,7,8,9

快速排序插入排序希尔排序系统方法冒泡排序清空

测试数组长度：
测试次数：10次
数组太长请慎用冒泡排序

算法	数组长度	分别用时(毫秒)	平均(毫秒)	点击测试
快速排序	1000	1, 1, 0, 1, 0, 0, 0, 0, 0, 0,	0.3	测试
插入排序	1000	2, 2, 1, 1, 1, 1, 1, 2, 1, 1,	1.3	测试
希尔排序	1000	1, 0, 1, 0, 0, 0, 1, 1, 0, 0,	0.4	测试
系统方法	1000	0, 0, 0, 0, 0, 1, 0, 0, 0, 1,	0.2	测试
冒泡排序	1000	6, 5, 5, 5, 3, 4, 5, 5, 5, 5,	4.8	小心测试

个人理解：

冒泡排序：最简单，也最慢，貌似长度小于7最优
插入排序：比冒泡快，比快速排序和希尔排序慢，较小数据有优势
快速排序：这是一个非常快的排序方式，V8的sort方法就使用快速排序和插入排序的结合
希尔排序：在非chrome下数组长度小于1000，希尔排序比快速更快
系统方法：在forfox下系统的这个方法非常快

JavaScript Code

 
<script type="text/javascript"> 
 
      002Jun = {};
 
      003Jun.array = {
 
      
 
     
 
    df:function(len){ 
 
        var array = [], i; 
 
        len = len || 1000; 
 
        for(i = 0; i< len; i++){ 
 
            array.push(i); 
 
        } 
 
        return array.sort(function(){ return Math.random() > 0.5}); 
 
    }, 
 
    // Jun.array.test(); 
 
    test:function(method, arrayLength, callBack){ 
 
         
 
        var times = []; 
 
        var i = 0; 
 
        var sum = 0; 
 
        var len = 10; 
 
         
 
        for(;i<len;i++){ 
 
            test(); 
 
        } 
 
         
 
        for(i=0;i<times.length;i++){ 
 
            sum+=times[i]; 
 
        } 
 
         
 
         
 
      031 
 
        function test(){ 
 
            var array = Jun.array.df(arrayLength); 
 
            var st = new Date().getTime(); 
 
            Jun.array[method](array); //shellSort  quickSort  systemSort 
 
            var d = new Date().getTime() - st; 
 
            callBack && callBack(new Date().getTime() - st); 
 
            times.push(d); 
 
        } 
 
         
 
        return sum / len; 
 
    }, 
 
     
 
    // ---------- 一些排序算法 
 
    // js 利用sort进行排序 
 
    systemSort:function(array){ 
 
        return array.sort(function(a, b){ 
 
            return a - b; 
 
        }); 
 
    }, 
 
    // 冒泡排序 
 
    bubbleSort:function(array){ 
 
        var i = 0, len = array.length, 
 
            j, d; 
 
        for(; i<len; i++){ 
 
            for(j=0; j<len; j++){ 
 
                if(array[i] < array[j]){ 
 
                    d = array[j]; 
 
                    array[j] = array[i]; 
 
                    array[i] = d; 
 
                } 
 
            } 
 
        } 
 
        return array; 
 
    }, 
 
    // 快速排序 
 
    quickSort:function(array){ 
 
        //var array = [8,4,6,2,7,9,3,5,74,5]; 
 
        //var array = [0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7]; 
 
        var i = 0; 
 
        var j = array.length - 1; 
 
        var Sort = function(i, j){ 
 
             
 
            // 结束条件 
 
            if(i == j ){ return }; 
 
             
 
            var key = array[i]; 
 
            var stepi = i; // 记录开始位置 
 
            var stepj = j; // 记录结束位置 
 
             
 
            while(j > i){ 
 
                // j <<-------------- 向前查找 
 
                if(array[j] >= key){ 
 
                    j--; 
 
                }else{ 
 
                    array[i] = array[j] 
 
                    //i++ ------------>>向后查找 
 
                    while(j > ++i){ 
 
                        if(array[i] > key){ 
 
                            array[j] = array[i]; 
 
                            break; 
 
                        } 
 
                    } 
 
                } 
 
            } 
 
             
 
            // 如果第一个取出的 key 是最小的数 
 
            if(stepi == i){ 
 
                Sort(++i, stepj); 
 
                return ; 
 
            } 
 
             
 
            // 最后一个空位留给 key 
 
            array[i] = key; 
 
             
 
            // 递归 
 
            Sort(stepi, i); 
 
            Sort(j, stepj); 
 
        } 
 
         
 
        Sort(i, j); 
 
         
 
        return array; 
 
    }, 
 
     
 
    // 插入排序 
 
    insertSort:function(array){ 
 
         
 
        // http://baike.baidu.com/image/d57e99942da24e5dd21b7080 
 
        // http://baike.baidu.com/view/396887.htm 
 
        //var array = [0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7]; 
 
         
 
        var i = 1, j, step, key, 
 
            len = array.length; 
 
         
 
        for(; i < len; i++){ 
 
             
 
            step = j = i; 
 
            key = array[j]; 
 
             
 
            while(--j > -1){ 
 
                if(array[j] > key){ 
 
                    array[j+1] = array[j]; 
 
                }else{ 
 
                    break; 
 
                } 
 
            } 
 
             
 
            array[j+1] = key; 
 
        } 
 
         
 
        return array; 
 
    }, 
 
     
 
    // 希尔排序 
 
    //Jun.array.shellSort(Jun.array.df(10000)); 
 
    shellSort:function(array){ 
 
      148 
 
        // http://zh.wikipedia.org/zh/%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F 
 
        // var array = [13,14,94,33,82,25,59,94,65,23,45,27,73,25,39,10]; 
 
         
 
        var stepArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1]; // reverse() 在维基上看到这个最优的步长 较小数组 
 
        //var stepArr = [1031612713, 217378076, 45806244, 9651787, 2034035, 428481, 90358, 19001, 4025, 836, 182, 34, 9, 1]//针对大数组的步长选择 
 
        var i = 0; 
 
        var stepArrLength = stepArr.length; 
 
        var len = array.length; 
 
        var len2 =  parseInt(len/2); 
 
         
 
        for(;i < stepArrLength; i++){ 
 
            if(stepArr[i] > len2){ 
 
                continue; 
 
            } 
 
             
 
            stepSort(stepArr[i]); 
 
        } 
 
      166 
 
        // 排序一个步长 
 
        function stepSort(step){ 
 
             
 
            //console.log(step) 使用的步长统计 
 
             
 
            var i = 0, j = 0, f, tem, key; 
 
            var stepLen = len%step > 0 ?  parseInt(len/step) + 1 : len/step; 
 
             
 
             
 
            for(;i < step; i++){// 依次循环列 
 
      177 
 
                for(j=1;/*j < stepLen && */step * j + i < len; j++){//依次循环每列的每行 
 
                    tem = f = step * j + i; 
 
                    key = array[f]; 
 
      181 
 
                    while((tem-=step) >= 0){// 依次向上查找 
 
                        if(array[tem] > key){ 
 
                            array[tem+step] = array[tem]; 
 
                        }else{ 
 
                            break; 
 
                        } 
 
                    } 
 
                     
 
                    array[tem + step ] = key; 
 
                     
 
                } 
 
            } 
 
             
 
        } 
 
         
 
        return array; 
 
         
 
    } 
 
 }; 
 
      201</script>
 
      202 
 
<script type="text/javascript"> 
 
    var jelle = { 
 
        index:1, 
 
        $:function(id){ 
 
            return document.getElementById(id); 
 
        }, 
 
        test:function(method, num){ 
 
            var arrayLength = parseInt(jelle.$('arrayLength').value); 
 
            jelle.index = num; 
 
            jelle.$('length_'+num).innerHTML = arrayLength; 
 
            jelle.$('times_'+num).innerHTML = ''; 
 
            jelle.$('time_'+num).innerHTML = Jun.array.test(method, arrayLength, jelle.insert);; 
 
        }, 
 
        insert:function(num){ 
 
            jelle.$('times_'+jelle.index).innerHTML += num+', '; 
 
        }, 
 
        correctness:function(method){ 
 
            var array = new Function('return '+ jelle.$('testArray').value)(); 
 
            jelle.$('testResults').innerHTML += '<div>['+method+']: '+Jun.array[method](array)+'</div>'; 
 
        } 
 
    } 
 
      224</script>

随机文章推荐

网站分类

注：如需转载本文，请注明出处（原文链接），谢谢。更多精彩内容，请进入简明现代魔法首页。

进入新博客

so_fast

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
转：JavaScript排序性能比较

http://www.nowamagic.net/javascript/js_SortEffectiveInJavascript.phpJavaScript排序性能比较2011-02-15排序是经常使用的编程例子，在JavaScript里各种排序的性能又如何呢？每个浏览器测试得出的数据会不一样。比如我用chrome 测试一般快速排序都会最快，IE 则根据数组长度有可能希尔最...
复制链接

扫一扫