javascript数组的经常使用算法解析

1、不改变原数组，返回新数组(字符串)

一、concat() 链接两个或者多个数组，两边的原始数组都不会变化，返回的是被链接数组的一个副本。

二、join() 把数组中全部的元素放入到一个字符串中，返回字符串

var a = [1,2,3];
a.join([4,5,6]);    //  "14,5,624,5,63"
a.join('sau');      //  "1sau2sau3"

三、slice() 从开始到结束（不包括结束）选择数组的一部分浅拷贝到一个新数组

var a  = [1,2,3,4,5];
a.slice(0,0);     //[]
a.slice(0,1);     //[1]
a.slice(2,4);    //[3,4]
a.slice(0,5);    //[1,2,3,4,5]
a.slice(10,1);   //[]
a.slice(4);   //[5]

四、map() 建立一个新的数组并返回，其中新数组的每个元素由调用原始数组中的每个元素执行提供的函数得来，原数组不变

五、every() 对数组中的每个元素都执行一次指定的回调函数，直到回调函数返回false，此时every()返回false并再也不继续执行，若是回调函数都对每个元素都返回true，那么every()返回true。

六、some() 对数组中的每个元素都执行一次指定的回调函数，直到回调函数返回true，此时some()返回true并再也不执行。若是回调函数对每个元素都返回false，那么some()将返回false。

七、filter() 建立一个新数组，其中包含经过所提供函数实现的测试的全部元素。

2、改变原数组

一、forEach() 针对每个元素执行提供的函数。会修改原来的数组，不会返回执行结果，返回undefined。

二、pop() 删除数组最后一个元素，返回被删除的元素的值，若是数组为空，则不改变数组，返回undefined。

三、push() 向数组末尾添加一个或多个元素，返回改变后数组的长度。

四、reverse() 颠倒数组中元素的位置，返回该数组的引用。

五、shift() 从数组中删除第一个元素，改变原数组，并返回该元素的值。

六、unshift() 将一个或者多个元素添加到数组的开头，并返回新数组的长度。

七、sort() 对数组的元素进行排序，返回数组。排序不必定是稳定的。默认排序顺序是根据字符串unicode码点。

八、splice() 向数组中添加/删除元素，而后返回被删除的新数组()。

var a  = [1,2,3,4,5];
a.splice(0,1);     //删除从0位置开始的1个   返回[1]   a为[2,3,4,5] 
a.splice(1,0,99)   //在1的位置插入99   [2,99,3,4,5]
a.splice(1,1,88)   //99替换为88  [2,88,3,4,5]

3、遍历方法

一、获取属性名：for...in 和object.key()的区别

答：一、for in 遍历对象能够枚举的属性名列表，包括[[prototype]]原型链；

二、Object.keys() 只查找属性名是否在对象中，返回一个数组，包含全部能够枚举的属性名；

三、Object.getOwnPropertyNames()只查找属性名是否在对象中，返回一个数组，包含全部的属性名，不管是否可枚举。

二、获取属性值： for... of 和object.values()

for of 语句：遍历可迭代对象的可枚举属性值列表，包括[[propertype]]原型链；

object.values() :返回一个给定对象自身的全部可枚举属性的值，不包括原型链。

4、ES6语法Map键值对转化为数组

new Map建立一个map

// new Map建立一个map
let map = new Map([[1,"one"], [2,"two"], [3,"three"]]);
map.set(4, "four");

// 获取全部键值对
console.log("获取key")
console.log([...map.keys()]) // 输出[1, 2, 3, 4]

console.log("获取value")
console.log([...map.values()]) // 输出[one, two, three, four]

console.log("获取map数组")
console.log([...map]) // 输出[[1, "one"], [2, "two"], [3, "three"], [4, "four"]]

5、两个升序的数组合并成一个升序数组

一、时间复杂度O(M+N)，空间复杂度O(M+N)

function merge(left, right){
    let result  = [],
        il      = 0,
        ir      = 0;

    while (il < left.length && ir < right.length) {
        result.push(left[il] < right[ir] ? left[il++] : right[ir++]);
console.log(result);
    }

    return result.concat(left.slice(il)).concat(right.slice(ir));
}

二、时间复杂度O(M+N)，空间复杂度O(1)

// m, n 是数组长度
function merge(left, m, right,  n) {
    var i = m - 1, j = n - 1, writeIdx = m + n - 1;
    while (i >= 0 && j >= 0)
    left[writeIdx--] = left[i] > right[j]? left[i--] : right[j--];
    while (j >= 0)
    left[writeIdx--] = right[j--];
    return left;
}

6、数组重复问题

（一）数组去重

一、reduce方法

const distinct = arr => arr.sort().reduce( (init, current) => {
    
    if (init.length === 0 || init[init.length - 1] !== current) {
        init.push( current );
    }
    return init;
}, []);

let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
distinct(arr); // [1, 2, 3, 4, 5]

二、filter方法

const distinct = arr => arr.filter( (element, index, self) => {

return self.indexOf( element ) === index;

});

let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
distinct(arr); // [1, 2, 3, 5, 4]

（二）排序数组去重

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    
    if(!nums || nums.length == 0) return 0;
    
    let len = 0;
    for(let i = 1; i < nums.length; i++) {
        if (nums[len] != nums[i]) {
            nums[++ len] = nums[i];
        }
    }
    return len + 1;
};

（三）判断数组是否存在重复

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    
    let hashMap = new Map();
    for(let i = 0; i < nums.length; i++) {
        
        if( hashMap.has(nums[i]) ) {
           return true;
        }
        
        hashMap.set(nums[i], 1);
    }
    
    return false;
};

7、两个数组的交集

给定两个数组，写一个方法来计算它们的交集。

例如:

给定 nums1 = [1, 2, 2, 1], nums2 = [2, 2], 返回 [2, 2].

注意：一、出结果中每一个元素出现的次数，应与元素在两个数组中出现的次数一致。二、

咱们能够不考虑输出结果的顺序。
跟进：一、若是给定的数组已经排好序呢？你将如何优化你的算法？二、若是 nums1 的大小比 nums2 小不少，哪一种方法更优？三、若是nums2的元素存储在磁盘上，内存是有限的，你不能一次加载全部的元素到内存中，你该怎么办？

解法：

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    
    var map1 = new Map();
    var number = [];
    
    for(var i = 0; i < nums1.length; i++) {
        var map1Value = map1.get(nums1[i]);
        map1.set( nums1[i], ( map1Value ? map1Value : 0 ) + 1 );
    }
    
    for(var i = 0; i < nums2.length; i++) {
        if( map1.has(nums2[i]) && map1.get(nums2[i]) != 0 ) {
            number.push(nums2[i]);
            map1.set( nums2[i], map1.get(nums2[i]) - 1 );
        }
    }
    
    return number;
};

8、找出一个数组中只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次之外，其他每一个元素均出现两次。找出那个只出现了一次的元素。

/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function(nums) {
    
    let number = 0;
    for(let i = 0; i < nums.length; i++) {
        number ^= nums[i];
    }
    return number;
};