标签：计算 reduce round strong ike object 结构 数组 back
一、数组扁平化
有数组：let arr = [[2, 3, 1],[4, 3, 6, 5],[6, 2, 4, 9, [4, 11, 12, [12, 13, [10], 15]]], 20]
1. reduce
//若值为数组则递归遍历，否则concat function flatten(arr) { return arr.reduce((result, item)=> { return result.concat(Array.isArray(item) ? flatten(item) : item); }, []); } //reduce是数组的一种方法，它接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。 //reduce包含两个参数：回调函数，传给total的初始值 // 求数组的各项值相加的和： arr.reduce((total, item)=> { // total为之前的计算结果，item为数组的各项值 return total + item; }, 0);
2.toString & split
//调用数组的toString方法，将数组变为字符串然后再用split分割还原为数组 function flatten(arr) { return arr.toString().split(‘,‘).map(function(item) { return Number(item); }) } //因为split分割后形成的数组的每一项值为字符串，所以需要用一个map方法遍历数组将其每一项转换为数值型
3.join & split
//和上面的toString一样，join也可以将数组转换为字符串 function flatten(arr) { return arr.join(‘,‘).split(‘,‘).map(function(item) { return parseInt(item); }) }
4. 递归
function flatten(arr) { var res = []; arr.map(item => { if(Array.isArray(item)) { res = res.concat(flatten(item)); } else { res.push(item); } }); return res; }
5.扩展运算符
//es6的扩展运算符能将二维数组变为一维 [].concat(...[1, 2, 3, [4, 5]]); // [1, 2, 3, 4, 5] //根据这个结果我们可以做一个遍历，若arr中含有数组则使用一次扩展运算符，直至没有为止。 function flatten(arr) { while(arr.some(item=>Array.isArray(item))) { arr = [].concat(...arr); } return arr; }
二、去重
1、去重方法一(Set)
var duplicate = Array.from(new Set(newArr1))
2、去重方法二(reduce)
//通过数组reduce方法，利用indexOf判断上一次回调返回数组a中是否包含当前元素b的索引，如果不存在，则把b元素加入a数组，否则直接返回a。 var duplicate1 = newArr1.reduce((a, b) => { if(a.indexOf(b) === -1) { a.push(b) } return a }, [])
3、去重方法三(数组下标去重法)
//通过数组的过滤filter方法，利用indexOf获取当前元素ele在被过滤数组farr中的第一个索引值，如果值与当前索引值index相等则返回，如果不相等则过滤。 var duplicate2 = newArr1.filter((ele, index, farr) => { return farr.indexOf(ele) === index })
4、去重方法四(遍历数组)
//遍历数组，建立新duplicate3 数组，利用indexOf判断元素是否存在于duplicate3 新数组中，不存在则push到duplicate3 新数组。 var duplicate3 = [] for(var i = 0; i < newArr1.length; i++) { if(duplicate3.indexOf(newArr1[i]) === -1) { duplicate3.push(newArr1[i]) } }
5、去重方法五(排序后相邻去重法)
//给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前一值重复的值。 function unique3(arr) { arr.sort(); var newArr = [arr[0]]; for(var i = 1, len = arr.length; i < len; i++) { if(arr[i] !== newArr[newArr.length - 1]) { newArr.push(arr[i]); } } return newArr; } var duplicate4 = unique3(newArr1)
三、数组排序
有数组：let initarr=[12, 13, 2, 5, 4, 8, 6, 9, 11, 15, 1, 3, 10, 14, 16]
1、sort排序
function arrSort(arr) { return arr.sort(function(a, b) { return a - b }) } var sort = arrSort(initarr)
2、冒泡排序
function bubbleSort(arr) { var len=arr.length for(var i = len-1; i > 0; i--) { for(var j = 0; j < i; j++) { if(arr[j] > arr[j+1]) { var tmp = arr[j] arr[j] = arr[j + 1] arr[j + 1]= tmp } } } return arr } var sort1 = bubbleSort(initarr)
3、插入排序
function insertSort(arr) { // 假设第一个元素已经排好序 for (let i = 1; i < arr.length; i++) { if (arr[i] < arr[i - 1]) { // 取出无序序列中需要插入的第i个元素 var temp = arr[i]; // 定义有序中的最后一个位置 var j = i - 1; arr[i] = arr[j]; // 根据序列最后一位，不断循环比较，找到插入的位置 while(j >= 0 && temp < arr[j]){ arr[ j+1 ] = arr[j]; j--; }; //插入 arr[ j+1 ] = temp; } } }
var sort2 = insertSort(initarr)
4、希尔排序
function shellSort(arr) { var len = arr.length; // 定义间隔区间 var fraction = Math.floor(len / 2); // fraction = Math.floor(fraction / 2) => 循环中不断切割区间 for (fraction; fraction > 0; fraction = Math.floor(fraction / 2)) { // 以间隔值开始遍历 for (var i = fraction; i < len; i++) { // 如果前面一个大于后面一个 for (var j = i - fraction; j >= 0 && arr[j] > arr[fraction + j]; j -= fraction) { var temp = arr[j]; arr[j] = arr[fraction + j]; // 后移 arr[fraction + j] = temp; // 填补 } } } } var sort3 = shellSort(initarr)
四、交集、并集、差集
现有两数组a = [1, 2, 3]，b = [2, 4, 5]
1、ES7的方式
// 并集 let union = a.concat(b.filter(v => !a.includes(v))) // [1,2,3,4,5] // 交集 let intersection = a.filter(v => b.includes(v)) // [2] // 差集 let difference = a.concat(b).filter(v => a.includes(v) && !b.includes(v)) // [1,3]
2、ES6
let aSet = new Set(a) let bSet = new Set(b) // 并集 let union = Array.from(new Set(a.concat(b))) // [1,2,3,4,5] // 交集 let intersection = Array.from(new Set(a.filter(v => bSet.has(v)))) // 差集 let differenceNew = Array.from(new Set(a.concat(b).filter(v => aSet.has(v) && !bSet.has(v))))
3、ES5
// 并集 var union = a.concat(b.filter(function(v) { return a.indexOf(v) === -1})) // [1,2,3,4,5] // 交集 var intersection = a.filter(function(v){ return b.indexOf(v) > -1 }) // [2] // 差集 var difference = a.filter(function(v){ return b.indexOf(v) === -1 })// [1,3]
考虑有NaN
var a = [1, 2, 3, NaN]; var b = [2, 4, 5]; var aHasNaN = a.some(function (v) { return isNaN(v) }) var bHasNaN = b.some(function (v) { return isNaN(v) }) // 并集 var union = a.concat(b.filter(function (v) { return a.indexOf(v) === -1 && !isNaN(v) })).concat(!aHasNaN & bHasNaN ? [NaN] : []) // [1,2,3,4,5,NaN] // 交集 var intersection = a.filter(function (v) { return b.indexOf(v) > -1 }).concat(aHasNaN & bHasNaN ? [NaN] : []) // [2] // 差集 var difference = a.filter(function (v) { return b.indexOf(v) === -1 && !isNaN(v) }).concat(aHasNaN && !bHasNaN ? [NaN] : [])//1,3,NaN
标签：计算 reduce round strong ike object 结构 数组 back
原文地址：https://www.cnblogs.com/sonechao/p/14851300.html
