js数组去重与性能分析(时间复杂度很重要)

随着js的深入和实际项目对性能的要求,算法的简单实现已经不能满足需要,在不同的应用场景下,时间复杂度很重要。

首先是创建数组与性能处理函数:

// 保证时间差的明显程度,创建不同量级的数组,size为数组的量级
function createArr (size) {
    var len = size/100
    var create = []
    for (var i=0; i<100; i++ ) {
        for(var j=0; j<len; j++) {
            create.push(j)
        }
    }

    return create
}

// 以回调的方式
function checkTime (fn) {
    var date1 = new Date().getTime()
    var create = fn()
    var date2 = new Date().getTime()
    return {
        create: create,
        time: date2 - date1
    }
}

下面上不同去重函数的思路:

1. 常规思路,双层for循环,逐个去重

function singelArray (array) {
    var temp =[];
    for(var i = 0; i<array.length; i++) {
        for(var j = i+1; j<array.length; j++) {
            if (array[i] === array[j]) ++i
        }
        temp.push(array[i])
    }
    return temp;
}

2.为减少for循环层级,先为数组排序

function singelArray2 (array) {
    var temp = [array[0]]

    array.sort(function(a,b){
        return a - b;
    })

    for(var i=0;  i<array.length; i++) {
        if(array[i] !== temp[temp.length - 1]) {
            temp.push(array[i])
        }
    }

    return temp
}

3.利用对象属性唯一的特性

function singelArray3 (array) {
    var obj = {};
    var temp = []
    for (var i=0; i<array.length; i++) {
        if( !obj[array[i]] ) {
            temp.push(array[i]);
            obj[array[i]] = 1;
        } 

    }
    return temp
}

4. ES6 新增数据结构

function singelArray4 (array) {
    return new Array(...(new Set(array)))
}

*******性能测试

为避免误差,不同量级的数组操作四次

// 百万量级
var lgArr = createArr(1000000)
var res = checkTime(function(){return singelArray(lgArr)});
var res2 = checkTime(function(){return singelArray2(lgArr)});
var res3 = checkTime(function(){return singelArray3(lgArr)});
var res4 = checkTime(function(){return singelArray4(lgArr)});
console.log(res)  // 常规思路       time: 119   115   116    115
console.log(res2) // 先排序         time: 769   774   768    775
console.log(res3) // 对象属性唯一   time: 14    15    14     14
console.log(res4) // es6 Set        time: 25    24    26     26
// 千万量级
var lgArr = createArr(10000000)
var res = checkTime(function(){return singelArray(lgArr)});
var res2 = checkTime(function(){return singelArray2(lgArr)});
var res3 = checkTime(function(){return singelArray3(lgArr)});
var res4 = checkTime(function(){return singelArray4(lgArr)});
console.log(res)  // 常规思路       time: 10542   10549   10550   10540
console.log(res2) // 先排序         time: 8130      8146    8072    8031
console.log(res3) // 对象属性唯一   time: 119     118     118     118
console.log(res4) // es6 Set        time: 253     247     243     239

五千万量级和一亿量级尝试了下,时间着实长了点...  作者电脑可能垃圾了,有兴趣的可以自己测一下。

总体来看在考虑兼容性的情况下,推荐使用第三种方法,可用ES6时,建议使用第四种方法。或者统一使用ES6方法,最后再用babel转一下,不过小编没试过,不好妄下评论。

原文地址:https://www.cnblogs.com/pomelott/p/8849742.html

时间: 2024-10-14 06:26:06

js数组去重与性能分析(时间复杂度很重要)的相关文章

JS数组去重比较

数组去重复是一个常见的需求,我们暂时考虑同类型的数组去重复.主要是理清思路和考虑执行性能. for循环删除后面重复的 var uniqueFor = function(arr) { for (var i = 0; i < arr.length - 1; i++) { var item = arr[i]; for(var j = i+1; j < arr.length; j++ ) { item === arr[j] && (arr.splice(j, 1), j--); } }

js 数组去重的方法总结

想沉淀一下自己.代码改变世界~~~ 1.利用Array.from代码如下 1 var arr = [1,2,3,4,3,2,1] 2 function unique(arr){ 3 return Array.from(new Set(arr)) 4 } 5 console.log(unique(arr)) 2.利用es6(...)拓展运算符.demo 1 var arr = [1,2,3,4,3,2,1] 2 function unique(arr){ 3 return [...new Set(

JS数组去重的几种常见方法

JS数组去重的几种常见方法 一.简单的去重方法 // 最简单数组去重法 /* * 新建一新数组,遍历传入数组,值不在新数组就push进该新数组中 * IE8以下不支持数组的indexOf方法 * */ function uniq(array){ var temp = []; //一个新的临时数组 for(var i = 0; i < array.length; i++){ if(temp.indexOf(array[i]) == -1){ temp.push(array[i]); } } ret

js 数组去重(数组元素是对象的情况)

js数组去重有经典的 几种方法 但当数组元素是对象时,就不能简单地比较了,需要以某种方式遍历各值再判断是否已出现. 因为: 1.如果是哈希判断法,对象作哈希表的下标,就会自动转换成字符型类型,从而导致所有元素都相等,这时判断方法不再有意义.一般最后数组就只剩一个 2.如果是直接比较法,则因为对象在内存中是按引用访问的,属性值相同的对象也不会相等,简单的直接判断不再有意义.一般最后数组还是原样 所以就需要进行值的比较 当然了,也可以换着法来将相应对象转为字符串(不是默认的那种[object Obj

js数组去重的4种方法

js数组去重,老生长谈,今天对其进行一番归纳,总结出来4种方法 贴入代码前 ,先对浏览器Array对象进行支持indexOf和forEach的polyfill Array.prototype.indexOf = Array.prototype.indexOf || function(item) { for (var i = 0, j = this.length; i < j; i++) { if (this[i] === item) { return i; } } return -1; } Ar

JS数组去重,js中数组(Array)的排序(sort)

JS数组去重 var ddd = [1,2,4,5,2, 222,1,5,6]; var uq = {}; var rq = []; for(var i=0; i<9; i++){ if(!uq[ddd[i]]){ uq[ddd[i]] = true; rq.push(ddd[i]); } } return rq; js中数组(Array)的排序(sort)注意事项 var arrDemo = new Array(); arrDemo[0] = 10; arrDemo[1] = 50; arrD

js数组去重常用方法

js数组去重是面试中经常会碰到的问题,无论是前端还是node.js数组常见的有两种形式,一种是数组各元素均为基本数据类型,常见的为数组字符串格式,形如['a','b','c'];一种是数组各元素不定,元素中既有基本数据类型,也有引用数据类型,形式如[{name:1,age:2}];这里介绍两种常见的js去重方式. 方法一:针对数组字符串形式(利用set) let arr = [1,2,3,4,5,4,3,2,1]; let set = new Set(); arr.forEach((item)=

前端面试必备:JS数组去重算法实现

之前一段时间一直在准备面试, 因而博客太久没更新: 现在基本知识点都复习完毕, 接下来就分享下 面试的一些常见问题: 去正规的互联网公司笔试.面试有很大的概率会碰到 使用javascript实现数组去重 的编码问题: 如:魅族笔试题: 本博文就js 如何实现数组去重整理出5种方法,并附上演示Demo 以及 源码.  1.遍历数组法   最简单的去重方法, 实现思路:新建一新数组,遍历传入数组,值不在新数组就放入该新数组中:注意点:判断值是否在数组的方法“indexOf”是ECMAScript5

JS数组去重算法实现

转帖: https://github.com/wteam-xq/testDemo/blob/master/array.html 1.遍历数组法 最简单的去重方法, 实现思路:新建一新数组,遍历传入数组,值不在新数组就加入该新数组中:注意点:判断值是否在数组的方法“indexOf”是ECMAScript5 方法,IE8以下不支持,需多写一些兼容低版本浏览器代码,源码如下: // 最简单数组去重法 function unique1(array){ var n = []; //一个新的临时数组 //遍