关于Array常见问题

1.数组去重

let arr = [1, 1, 2, 2, 3, 3, 4, 4, 1, 1, 5]

//第一种
Array.from(new Set(arr))

//第二种loadsh
_.uniq(arr)

//第三种双重for循环，利用splice去重
function unique(arr){            
    for(let i = 0; i < arr.length; i ++){
        for(let j = i + 1; j < arr.length; j ++){
            if(arr[i] == arr[j]){ //第一个等同于第二个，splice方法删除第二个
                arr.splice(j, 1);
                j--;
            }
        }
    }
    return arr;
}

//第四种 利用indexof
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array = [];
    for (let i = 0; i < arr.length; i ++) {
        // 判断array中是否已经存在当前元素，如果不存在，则增加
        if (array.indexOf(arr[i]) === -1) { 
            array.push(arr[i])
        }
    }
    return array;
}

// 第五种 利用sort 
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return;
    }
    arr = arr.sort()
    let arrry= [arr[0]];
    for (let i = 1; i < arr.length; i++) {
        // 通过sort排序 只要判断相邻两个元素是否相同
        if (arr[i] !== arr[i-1]) {
            arrry.push(arr[i]);
        }
    }
    return arrry;
}

// 第六种 利用includes
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array =[];
    for(let i = 0; i < arr.length; i++) {
        //includes 检测数组是否有某个值
        if(!array.includes(arr[i])) {
            array.push(arr[i]);
        }
    }
    return array
}

// 第七种 利用filter
function unique(arr) {
  return arr.filter(function(item, index, arr) {
    //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
    return arr.indexOf(item, 0) === index;
  });
}

// 第八种 利用递归去重
function unique(arr) {
    let array= arr;
    let len = array.length;
    array.sort(function(a,b){   //排序后更加方便去重
        return a - b;
    })

    function loop(index){
        if(index >= 1){
            if(array[index] === array[index-1]){
                array.splice(index,1);
            }
            loop(index - 1); //递归loop，然后数组去重
        }
    }
    loop(len-1);
    return array;
}

//第九种 利用map数据结构去重
function unique(arr) {
    let map = new Map();
    let array = new Array();  // 数组用于返回结果
    for (let i = 0; i < arr.length; i++) {
        if(map.has(arr[i])) {  // 如果有该key值
            map.set(arr[i], true); 
        } else { 
            map .set(arr[i], false);   // 如果没有该key值
            array .push(arr[i]);
        }
      } 
  return array ;
}

2.数组排序

// 第一种 桶排序
//简单, 但是不用,浪费内存,因为是用数组下标进行排序的,所以受限制比较多,只能用来排列纯数字数组,且数组内的值都是唯一的
let arr = [1, 43, 3, 2, 5, 99, 6] // 待排序
let arr2 = [] 
let arr3 = [] // 最终排序结果
for(let i = 0; i < arr.length; i++){
    let key = arr[i];
    arr2[key] = 1;
}
for(let j in arr2){
    arr3.push(parseInt(j)) 
}


//第二种 冒泡排序
//性能一般
//冒泡排序,每一趟找出最大的,总共比较次数为arr.length-1次,每次的比较次数为arr.length-1次，依次递减
let arr = [1,5,7,9,16,2,4];
let temp;
for(let i = 0; i < arr.length - 1; i++){
    for(let j = 0; j < arr.length - 1; j++){
        if(arr[j] > arr[j+1]){
            temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

// 第三种 快速排序 1/2排序
function quickSort(arr){
    // 如果数组就一个值就不用排序
    if(arr.length <= 1){
        return arr;
    }
    let left = [] 
    let right = []
    let midIndex = parseInt(arr.length / 2) // 取出数组中间那个值得下标
    let mid = arr[midIndex]
    for(let i = 0 ; i < arr.length ; i++){
        if(i == midIndex) continue; // 如果是中间值就直接跳过比较
        if(arr[i] < mid){
            left.push(arr[i])
        }else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([mid],quickSort(right))
}

//第四种 插入值排序
// 就是把原数组值一个拿出来一次一个插入进行比较排序
let arr=[45, 1, 32, 21, 56, 87, 43, 12, 34, 45]
for(let i = 0; i < arr.length; i ++){
    let n = i
    while(arr[n] > arr[n+1] && n >= 0){
 	    let temp = arr[n];
	    arr[n] = arr[n+1];
 	    arr[n+1] = temp;
	    n--;
    }
}

//第五种 希尔排序
// 跟快速排序类似,可是性能确大大提高了
function xier(arr){
    let interval = parseInt(arr.length / 2);  //分组间隔设置
    while(interval > 0){
        for(let i = 0 ; i < arr.length ; i ++){
            let n = i
            while(arr[n] < arr[n - interval] && n > 0){
                let temp = arr[n]
                arr[n] = arr[n - interval]
                arr[n - interval] = temp
                n = n - interval
            }
        }
        interval = parseInt(interval / 2);
    }
    return arr;
}


//第六种 sort排序
①
//一维数组排序
let arr=[1,5,7,9,16,2,4];
arr.sort(function(a,b){
    return b-a;  //降序排列，return a-b; —>升序排列
})  //括号里不写回调函数，则默认按照字母逐位升序排列，结果为[1,16,2,4,5,7,9]

②
//对象数组排序
let arr = [
    {name: 'root', age: 0},
    {name: 'zmz', age: 18},
    {name: 'cg', age: 8},
    {name: 'zz', age: 20}
];
 
function compare(property){
    return function(a,b){
        let value1 = a[property];
        let value2 = b[property];
        return value1 - value2;//升序,降序为value2 - value1
    }
}
arr.sort(compare('age'))

// 第七种 loadsh
①排序数组/对象
let arr = [
    {name:'root',age:0},
    {name:'zmz',age:18},
    {name:'cg',age:8},
    {name:'zz',age:20}
];
_.sortBy([1,4,2,3])
_.sortBy(arr, ["age"])
② 排序并且去重，返回一个新数组
_.sortedUniq([1, 1, 2]);

3.数组最大值

//第一种 利用排序取出最大值
let arr = [1, 4, 99, 22, 67]
arr.sort()
let max = arr[arr.length - 1]

//第二种 比较法
let arr = [1, 4, 99, 22, 67]
let max = 0
for(let i = 0; i < arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}

//第三种 利用reduce
arr.reduce(
    (mx,item) => {
        if(max < item){
            max = item
        }
    return max
    }
)

//第四种 利用Math
let arr = [1, 4, 99, 22, 67]
Math.max.apply(null, arr)
Math.max(...arr)

4.数值求和

// 第一种 递归
let arr = [1, 2, 3, 4, 5]
function sum(arr) {
    let len = arr.length
    if(len == 0){
        return 0
    }else if(len == 1){
        return arr[0]
    }else {
        return arr[0] + sum(arr.slice(1))
    }
}

// 第二种 常规循环
let arr = [1, 2, 3, 4, 5]
let sum = 0
for(let i = arr.length-1; i >= 0; i--) {
    sum += arr[i]
}

// 第三种 reduce
let arr = [1, 2, 3, 4, 5]
arr.reduce((prev, curr, idx, arr) => {
    return prev + curr;
})

// 第四种 foreach
let arr = [1, 2, 3, 4, 5]
let sum = 0
arr.forEach(item => { sum += item})

// 第五种 eval
let arr = [1, 2, 3, 4, 5]
let sum = eval(arr.join("+"))

5.数组合并

//第一种 concat
let a = [1, 2, 3]
let b = [4, 5, 6]
①js 返回一个新数组
a.concat(b)
②loadsh 返回一个新数组
_.concat(a, b)

//第二种 循环
let a = [1, 2, 3]
let b = [4, 5, 6]
①for
for(let i in b){
    a.push(b[i])
}
②forEach
b.forEach(item => {a.push(item)})
③map
b.map(item => {a.push(item)})

//第三种 apply
a.push.apply(a, b)

6.数值设值问题

①每一项设值

// 第一种 for
let arr = [1, 2, 3, 5, 11]
for(let i = 0; i < arr.length; i ++){
    arr[i] = 88
}

// 第二种 fill
//fill(value, start, end) value：填充值。start：填充起始位置，可以省略。end：填充结束位置，可以省略，实际结束位置是end-1。
let arr = [1, 2, 3, 4, 5, 6, 7, 8]
①fill(value)
arr.fill(66) //[66, 66, 66, 66, 66, 66, 66, 66]

②fill(value, start)
arr.fill(66, 4) //[1, 2, 3, 4, 66, 66, 66, 66] 

③fill(value, start, end)
arr.fill(66, 2, 5) // [1, 2, 66, 66, 66, 6, 7, 8]

②判断数组情况

// 两个数组取交集
let a = [1,2,3],b = [1,3,5]
a.filter( e => b.includes(e))
a.filter( e => b.indexOf(e) != -1)

// 两个数组的并集
a.concat(b.filter( e => !a.includes(e)))
a.concat(b.filter( e => a.indexOf(e)===-1))
Array.from(new Set(a.concat(b)))


// 两个数组取差值
a.filter( e => !b.includes(e)).concat(b.filter( v => !a.includes(v)))
a.filter(e => b.indexOf(e)===-1).concat(b.filter(e => a.indexOf(e)===-1))


// 取出数组中相同的元素
a.filter( e => b.indexOf(e) === -1)

7.数组转对象

//es6
let a = [1, 2, 3, 4, 5, 6]
let b = {...a}

//assign
let a = [1, 2, 3, 4, 5, 6]
let b = Object.assign({}, a)

//for
function toObj (arr) {
    let result = {};
    for(let a = 0; a < arr.length; a++) {
        result[a] = arr[a];
    }
    return result;
}

8.数组降维(拍平数组)

// js
let arr = [[1,3],[5,[7]],0,7,6,99,5]
//flat方法什么都不传默认向下拍一维，如下三维数组拍成二维
//传数字，传多少flat拍多少，如下传2将arr拍成一维数组
//Infinity,直接拍成一维数组
arr.flat() //=>[1, 3, 5, [7], 0, 7, 6, 99, 5]
arr.flat(2) //=>[1, 3, 5, 7, 0, 7, 6, 99, 5]
arr.flat(Infinity) //=>[1, 3, 5, 7, 0, 7, 6, 99, 5]

//loadsh
let arr = [[1,3],[5,[7]],0,7,6,99,5]
//只降一维
_.flatten(arr)

//第二个参数代表降维
_.flattenDepth(arr, 1);

// 直接拍平
_.flattenDeep(arr)

9.数组增加元素

// push
//在数组的最后一个元素位置增加元素
let arr = [1, 2, 3]
arr.push(4, 5) //[1, 2, 3, 4, 5]

//unshift
// 在数组的第一个元素位置增加元素
let arr = [1, 2, 3]
arr.unshift(4, 5) //[4, 5, 1, 2, 3]

// splice
// 在数组指定的位置增加元素
let arr = [1, 2, 3]
arr.splice(2, 0, 'cg') //[1, 2, 'cg', 3]

10.数组删除元素

// length
// 默认成数组尾巴删除 如果删除长度比原数组还要长 那会自动补充empty
let a = [1, 2, 3, 4]
a.length = 2 // [1, 2]
a.length = 6 // [1, 2, 3, 4, empty * 2]


// delete
// 删除出的位置还在，会变成empty/undefined
let a = [1, 2, 3, 4]
delete a[0] // [empty, 2, 3, 4]

//pop
//利用栈原理 后进先出
let a = [1, 2, 3, 4]
a.pop() // [1, 2, 3]

//shift
// 利用队列原理  先进先出
let a = [1, 2, 3, 4]
a.shift() // [2, 3, 4]

// splice
//可以指定要删除的位置
// 第一参数表示从什么位置删除 第二个参数表示要删除几个
let a = [1, 2, 3, 4]
a.splice(0, 1) // [2, 3, 4]

// 迭代
①
let a = [1, 2, 3, 4, 5]
a.forEach((item, index, arr) => {
    if(item === 1) {
        arr.splice(index, 1)   
    }
})
②
let a = [1, 2, 3, 4, 5]
a.filter(item => {return item != 2})