1. 数组扁平化
方法一 : 递归迭代数组
function steamrollArray(arr,res=[]) { //res用来保存需要返回的数组
for (const [k, v] of arr.entries()) {// 取出数组的键值对进行遍历
// 如果元素为数组类型,则继续递归, 否者将其添加到res中
v instanceof Array ? factorysteamrollArray(v,res) : res.push(v)
}
return list
}
方法二 : 通过js原生 falt方法展开数组
function steamrollArray(){
//flat函数第一个参数为展开的维度, isFinite关键字意思是不管数组嵌套的多少层,都转为一维数组
return arr.flat(isFinite)
}
方法三 通过正则匹配
function steamrollArray1(arr){
// 将数组序列化, 利用replace将数组中所有的[或]字符全部替换为"",
let josn = JSON.stringify(arr).replace(/\[|\]/g,"");
// 利用split将字符串通过逗号隔开转为数组,对其进行迭代
return josn.split(",").map(v => +v);// +号运算符字符串转为数字
}
2. 数组去重
方法一 通过 includes
function unique(arr){
let res = [];
arr.forEach( item =>{
if(!res.includes(item)) res.push(item)
})
return item
}
方法二通过 set
function unique(arr){
return Array.from(new Set(arr))
}
方法三 利用indexOf查找数组索引
function unique(arr){
let res = []
for(let i = 0,len = arr.length; i <len; i++){
let list = arr.slice(i+1,arr.length),
index = list.indexOf(arr[i]);
if(index === -1) res.push(arr[i]);
}
return res
}
方法四. 通过 reduce
function unique(arr){
return arr.reduce((res,item,index) =>{
if(!res.includes(item)) res.push(item)
return res
},[])
}
3 计算数组之和
方法一利用 数组高阶函数 reduce
function sum(arr){
return arr.reduce((total,item) =>{
return total + item
})
}
方法二 利用原生for循环迭代
function sum(arr){
let total = 0;
for(let i = 0,len = arr.length; i < len; i ++){
count += arr[i]
}
return total
}
方法三 利用递归
function sum(arr){
return arr.length == 0 ? 0: arr.pop() + sum(arr)
}
方式四 利用数学思维,首尾相加 减少迭代次数
function sum(arr){
let total = 0,
isOdd = arr.length % 2 == 0;// 判断数组长度是否为偶数
const length = arr.length;
for(let i = 0; i < length / 2; i++){//
let end = arr[length -i -1];//取出数组中每一项的对称数
// 如果数组长度为偶数,且下标为数组的中位项, 此时.他没有对称数则end赋值为 0
if(!isOdd && i === ~~( length / 2) ) end = 0
total += arr[i] + end
}
return total
}
4. 数组排序
方法一 通过js原生方法 sort
function Sort(arr){
return arr.sort( (a,b) => a - b ) //a - b 默认为升序
}
方法二 利用Math对象
function Sort(arr) {
let clone = arr.slice();
return arr.map(((item, index) => {
let min = Math.min.apply("", clone);
let findIndex = clone.indexOf(min);
clone.splice(findIndex, 1)
return min
}))
}
方法三 冒泡排序
function bubbleSort(arr) {
let res = [],
len = arr.length;
for (let i = 0; i < len - 1; i++) {
for (let j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
let tmp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = tmp
}
}
}
return arr
}
5. 随机打乱数组
方法一 利用Math.random方法 和splice
function randomSort(arr){
let clone = arr.slice();
return arr.map((item, index) => {
let num = Math.floor(Math.random() * clone.length)
let originIndex = clone.indexOf(clone[num]);
return clone[num]
clone.splice(originIndex, 1)
})
}
方法二 洗牌算法
function randomSort(arr){
let cloneArr = arr.slice()
for (let i = 0, len = arr.length; i < len; i++) {
let rand = parseInt(Math.random() * len);
let temp = cloneArr[rand];
cloneArr[rand] = cloneArr[i];
cloneArr[i] = temp;
}
return cloneArr;
}
洗牌算法,原理就是从根据数组的长度生成一个下标,将这个下标对应的数据保存起来.
然后从数组的下标0开始, 两两交换对应的数值.
映射到现实世界,类似于从牌堆随机里面抽出一张牌,然后将这张牌与第一张牌的位置进行交换.确保了每张牌,都交换了位置,随机性非常强.
方法三 根据 Array的sotr函数
function randomSort(arr){
let res = arr.slice()
res.sort(()=> Math.random() - 0.5 )
return res
}
6. 获取数组中出现次数最多的元素
方法一利用map和set, 来保存每个元素出现的次数.
function maxCOunt(arr){
let unique = Array.from(new Set(arr)),
map = new Map();
unique.forEach((item) =>{ map.set(item,0) })
arr.forEach((item,index) =>{
let count = map.get(item)
map.set(item,++count)
})
let values = map.values(),
data = [];
for (const item of values) { data.push(item) }
let max = Math.max.apply("",data);
for (const [k,v] of map.entries()) {
if(v == max) return k
}
}
7. 查找数组中 重复出现的元素
function duplicates(arr) {
let countArr = [],
length = arr.length;
for (let i = 0; i < length; i++) {
for (let k = i + 1; k < length; k++) {
if (arr[i] === arr[k]) {
countArr.push(arr[k])
}
}
}
let set = new Set(countArr);
let rs = Array.from(set);
return rs
}
网友评论