js 各种排序方法和sort方法的区别

最新推荐文章于 2024-04-21 13:47:44 发布
最新推荐文章于 2024-04-21 13:47:44 发布
阅读量3.5k 收藏 5
点赞数 1
分类专栏： javascript 文章标签： 测试 排序 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30100043/article/details/72763614
版权

今天突发奇想，想明白sort方法是否比各种排序都有优势，所以就参考别人的代码，做了一个测试，结果令人惊讶啊，上代码。

测试环境，随机选出若干个从0到1的随机数

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=0">
    <title>排序法测试</title>
</head>
<body>
<div id="div"></div>
<script>
    // ---------- 一些排序算法
    Sort = {
        // 利用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 tempi = i; // 记录开始位置
                var tempj = 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(tempi == i){
                    Sort(++i, tempj);
                    return ;
                }
                // 最后一个空位留给 key
                array[i] = key;
                // 递归
                Sort(tempi, i);
                Sort(j, tempj);
            }
            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, temp, key, len = array.length;
            for(; i < len; i++){
                temp = 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;
        },
        // 希尔排序
        shellSort:function(array){
            // 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 tempArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1];
            // reverse() 在维基上看到这个最优的步长 较小数组
            var tempArr = [1031612713, 217378076, 45806244, 9651787, 2034035, 428481, 90358, 19001, 4025, 836, 182, 34, 9, 1];
            //针对大数组的步长选择
            var i = 0;
            var tempArrLength = tempArr.length;
            var len = array.length;
            var len2 =  parseInt(len/2);

            for(;i < tempArrLength; i++){
                if(tempArr[i] > len2){
                    continue;
                }
                tempSort(tempArr[i]);
            }
            // 排序一个步长
            function tempSort(temp){
                //console.log(temp) 使用的步长统计
                var i = 0, j = 0, f, tem, key;
                var tempLen = len%temp > 0 ?  parseInt(len/temp) + 1 : len/temp;
                for(;i < temp; i++){// 依次循环列
                    for(j=1;/*j < tempLen && */temp * j + i < len; j++){
                        //依次循环每列的每行
                        tem = f = temp * j + i;
                        key = array[f];
                        while((tem-=temp) >= 0){
                            // 依次向上查找
                            if(array[tem] > key){
                                array[tem+temp] = array[tem];
                            }else{
                                break;
                            }
                        }
                        array[tem + temp ] = key;
                    }
                }
            }
            return array;
        }
    };
    testArrs = [];
    for (var i = 0; i < 100000; i++) {
        testArrs.push(Math.random());
    }

    function test(fun,arr) {
        let newArr = [];
        for(let i=0; i<arr.length; i++){
            newArr[i] = arr[i];
        }

        console.time('sort');
        var new_arr = Sort[fun](newArr);
        console.log(fun);
        console.timeEnd('sort');
    }

    /*
    * sort排序 systemSort
    * 冒泡排序 bubbleSort
    * 快速排序 quickSort
    * 插入排序 insertSort
    * 希尔排序 shellSort
    *
    * */

    test("systemSort",testArrs);
    test("bubbleSort",testArrs);
    test("quickSort",testArrs);
    test("insertSort",testArrs);
    test("shellSort",testArrs);
</script>
</body>
</html>

 

上面的方法通过测试时间，然后分析哪个排序方法省时，时间就是生命，用对正确的方法，就能省下好多时间，尤其是大数据运行的时候。

 

首先看运行处理10000个长度数组时的所用的时间：

* sort排序 systemSort 5
* 冒泡排序 bubbleSort 70
* 快速排序 quickSort 4
* 插入排序 insertSort 25
* 希尔排序 shellSort 7

测试十万长的数组数据：

* sort排序 systemSort  65
* 冒泡排序 bubbleSort  6592
* 快速排序 quickSort 16
* 插入排序 insertSort 2243
* 希尔排序 shellSort 20

测试一百万的长度的数组：

* sort排序 systemSort  751
* 冒泡排序 bubbleSort  时间未知
* 快速排序 quickSort 139
* 插入排序 insertSort 时间未知
* 希尔排序 shellSort 152

测试一千万长的数组：

* sort排序 systemSort  9833
* 冒泡排序 bubbleSort  没测
* 快速排序 quickSort 1512
* 插入排序 insertSort 没测
* 希尔排序 shellSort 2174

 

暮志未晚NAN
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
关于Sort排序与冒泡法的区别
hpjn_ycw的博客
09-03 2626
Sort排序和冒泡法的异同   对数组a{2,4,3,6,2,8,1}进行排序。 快速排序法 原理： 对于数组a{2,4,3,6,2,8,1} ①  需要选取一个关键元素作为基准元素key，用数组内所有元素跟基准元素比较大小 ②  先假设数组内第一个元素的角标为i，最后一个元素角标为j ③  先将数组元素最后一个元素跟基准元素比较，若a[j]>key,则j--,直到a[j] ④ 
基于js 各种排序方法和sort方法的区别(详解)
10-18
下面小编就为大家分享一篇基于js 各种排序方法和sort方法的区别(详解)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
sort();方法
最文艺的程序媛
07-17 922
DOCTYPE html> html> head> meta charset="UTF-8"> title>title> head> body> script type="text/javascript"> /*定义和用法 sort() 方法用于对数组的元素进行排序。 排序顺序可以是字母或数字，并按升序或降序。 默认排序顺序为按字母升序。 注意：当数字是按字母顺序排列时
JavaScript ES6新特性详解及实际应用案例
最新发布
LindRoland的博客
04-21 1068
ES6（ECMAScript 2015）作为JavaScript的一个重要版本，引入了许多新特性和语法糖，极大地提高了开发效率和代码的可读性。ES6引入了大量的新语法和API，包括let和const关键字、箭头函数、模板字符串、解构赋值、类（class）、模块（module）导入导出、Promise对象、异步函数（async/await）等。箭头函数是ES6中引入的一种新的函数语法。ES6提供了原生的模块系统，使得我们可以将代码拆分成不同的文件，并通过import和export语句来组织和共享代码。
js排序——sort()排序用法
热门推荐
前端小狮的博客
04-20 20万+
sort() 方法用于对数组的元素进行排序,并返回数组。默认排序顺序是根据字符串Unicode码点。 语法：array.sort(fun)；参数fun可选。规定排序顺序。必须是函数。 注：如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。 如果想按照其他规则进行排序，就需要提供比较函数，该函数要比较两个值，然后返回...
JavaScript-sort()排序
Bruce__taotao的博客
01-17 1248
sort()方法，可以对数组进行排序。该方法默认按照字符串的Unicode编码进行排序，也可以用自定义函数指定排序规则。（可选）：用于指定排序规则的函数。如果省略，则按照Unicode编码进行排序。如果要按照其他规则排序，可以使用自定义函数。自定义函数接收两个参数，分别是要比较的两个元素。根据两个元素的比较结果，返回负数、零或正数，表示两个元素的相对顺序。});此例中的自定义排序函数采用a - b的方式对数组进行升序排序，可以使用b - a进行降序排序。需要注意的是，sort()
JavaScript sort排序方法
qq_40626218的博客
03-04 272
一、 定义 函数 参数 返回值 sort(sortby) sortby 可选，规定顺序排序。 必须是参数。 数组的引用。 注意：在原数组上排序 注意： 1. 若没有使用参数，则按字母顺序（字符编码的顺序）对数组中的元素进行排序（注意：数字排序时也是按照字符编码的顺序，如：1<11<2） 2. 若想按照其他标准进行排序，则需要提供参数，.
js中数组排序sort方法的原理分析
12-01
本文实例分析了js中数组排序sort方法的原理。分享给大家供大家参考。具体分析如下： 最近在百度的项目中要用到对数组进行排序,当然一开始自然想到了数组的sort方法,这方法应用非常简单,大致如下: 代码如下: ...
JavaScript数组排序reverse()和sort()方法详解
11-28
在JavaScript中，数组排序是常见的数据操作之一，主要涉及到两种内置方法：`reverse()`和`sort()`。这两种方法都有其特定的用途和行为，本文将详细介绍它们的工作原理以及如何使用。 1. `reverse()`方法 `reverse()...
Js中的Sort排序方式
qq_33920944的博客
08-10 5162
Sort排序是数组内置函数，但他的排序是根据系统字符默认排序。
js【详解】arr.sort()数组排序（内含十大经典排序算法的js实现）
朝阳39的博客
05-14 9369
arr.sort()默认按照Unicode编码，从小到大进行排序，会改变原数组 let arr = ["e", "b", "d", "a", "f", "c", 1, 10, 2, 12]; let result = arr.sort() arr =[1,10,12,2,"a","b","c","d","e","f"] result =[1,10,12,2,"a","b","c","d","e","f"] 存在的致命缺陷：并没有按数字的大小进行排序，通常无法满足我们对数组的排序需求！ 自定义排序
JS数组排序技巧汇总(冒泡、sort、快速、希尔等排序)
10-23
主要介绍了JS数组排序技巧,实例汇总了JavaScript冒泡排序、sort排序、快速排序、希尔排序等,并附带分析了sort排序的相关注意事项,需要的朋友可以参考下
JS中sort()方法原理及使用
Front end development engineer
03-31 398
sort() 方法用于对数组的元素进行排序，并返回数组。默认排序顺序是根据字符串UniCode码。因为排序是按照字符串UniCode码的顺序进行排序的，所以首先应该把数组元素都转化成字符串（如有必要），以便进行比较。 语法：arrayObject.sort(sortby); 参数sortby 可选，用来规定排序的顺序，但必须是函数。 https://www.cnblogs.com/saifei/p/9043821.html ...
js数组sort排序方法的算法
weixin_30405421的博客
04-03 116
说明一下，ECMAScript没有定义使用哪种排序算法，各个浏览器的实现方式会有不同。火狐中使用的是归并排序，下面是Chrome的sort排序算法的实现。 　　sort方法源码 DEFINE_METHOD( GlobalArray.prototype, sort(comparefn) { CHECK_OBJECT_COERCIBLE(this, "Array...
JavaScript中数组的排序，冒泡排序，选择排序，以及sort方法排序
qq_42724864的博客
03-11 240
冒泡排序： **规则：**前后两个数两两进行比较，如果符合交换的条件，就交换两个数的位置； 规律：冒泡排序每一轮排序，都可以找出一个较大的数，然后进行交换位置； 分析：比较的轮数 = 数组的长度 - 1 每一轮比较的次数 = 数组的长度 -当前的轮数； 直接将排序方法定义成.js文件 然后在html文件中使用 function bubble(arr){ for(var i =0 ;i&...
javaScript--快速排序实现（不用sort）
iteye_8029的博客
04-19 336
&lt;!doctype html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;Document&lt;/title&gt; &lt;script type="text/javascript"&gt;
JS数组排序的两种方式：sort()方法和冒泡排序
Sinmeow的学习日记
12-15 669
一、使用sort()方法 let arrNew = arr.sort(function (a, b) { // return a - b //升序 默认 return b - a //倒序 }); console.log(arrNew);//[9, 8, 7, 6, 5, 4, 3, 2, 1] 二、冒泡排序   先声明一个空变量用来通过for循环嵌套，比较相邻的两个元素，如果...
【排序】快速排序 && 选择排序 && sort() 比较
( :3 )
11-21 216
#include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt; #include &lt;ctime&gt; #include &lt;cstdlib&gt; using namespace std; const int maxn = 10000; int a[maxn],b[maxn],c[maxn]; ...
JavaScript算法（实例三）数组排序--冒泡排序 / sort() / reverse() / 比较函数
jingjing的博客
08-09 205
1、使用算法实现数组[91, 76, 96, 23, 93]的冒泡排序。(循环体：相邻元素，如果前者比后者大，交换)。 var arr = [ 91, 76, 96, 23, 93 ]; console.log(arr); for(var i=0;i<arr.length;i++){ for(var j=0;j<arr.length-i-1;j++){ if(arr[j]>arr[j+1]){ var temp = arr[j];
js数组排序方法sort
05-17
JavaScript中的数组有一个sort()方法，用于对数组元素进行排序。这个方法会直接修改原数组，而不是返回一个新的排序好的数组。 sort()方法可以接受一个可选的比较函数作为参数，该函数定义了排序的方式。如果不传递...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值