数组操作系列

1. 判断是否为数组
2. 伪数组转为数组
3. 数组去重
4. 数组拍平
5. 排序算法

• 判断是否为数组

var arr = [1,2,3]

Array.isArray(arr)  // true
arr.constructor == Array  // true
arr instanceof Array  // true
Object.prototype.toString.call(arr)  // "[object Array]"

• 伪数组转为数组

// es5
Array.prototype.slice.call(arr)

//es6
Array.from(arr)

//es6 展开运算符
[...arr]

• 数组去重

// es5 循环遍历 (不能去重NaN和多个空对象/空数组)
function unique3(arr) {
    for(let i = 0; i < arr.length; i ++) {
        for (let j = i+1; j < arr.length; j ++) {
            if (arr[i] === arr[j]) {
                arr.splice(j,1)
                j-- 
            }
        }
    }
    return arr
}

// es5 indexOf (不能去重NaN和多个空对象/空数组)
function unique(arr) {
    let res = []
    arr.forEach(i => {
        if (res.indexOf(i) < 0) {
            res.push(i)
        }
    })
    return res
}

// es6  Set (不能去重多个空对象/空数组)
Array.from(new Set(arr))

// es6  Map&filter (不能去重多个空对象/空数组)
function unique(arr) {
    const tem = new Map()
    return arr.filter(i => {
       return !tem.has(i) && tem.set(i, 1)
    })
}

• 数组去重（各项包括复杂类型值的情况，但要注意NaN：JSON.stringify(NaN) => "null"，同时有null和NaN需要单独区分NaN）

function unique (arr) {
    var arr = [...new Set(arr)]  // Set只能去重简单数据类型值
    var res = []
    for(var i  = 0; i <= arr.length; i ++) {
        for(var j = arr.length - 1; j > i; j --){ // 倒序查找相同的项
            if (typeof arr[i] == 'object' && JSON.stringify(arr[i]) == JSON.stringify(arr[j])) {
                arr.splice(j,1)
            } 
        } 
    }
    return arr
}

• 数组拍平

// 递归
function flat(arr) {
    var res = []
    arr.forEach(i => {
        if (Array.isArray(i)) {
            res = res.concat(flat(i))
        } else {
            res.push(i)
        }
    })
    return res
}

// toString （只考虑了纯数组的情况）
function flat2(arr) {
    return arr.toString().split(',').map(i => +i)
}

// es6 flat（只能拍平一层）

• 数组排序

// 快排（任选一个数作为基准，其他数与之比较，小的放左边，大的放右边。递归排序）
// 冒泡的改进，时间复杂度 O(nlogn)
function qs(arr) {
    if (arr.length <= 1) {
        return arr
    }
    var left = [],
        right = [],
        base = arr.splice(0,1)
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < base[0]) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return qs(left).concat(base, qs(right))
}

// 冒泡（前后两两比较，大的交换到后面）时间复杂度O(n^2)
 function qs2(arr){
    	for(var i = 0 ; i < arr.length - 1; i ++) {
            for(var j = 0 ; j < arr.length - i - 1; j ++) {
                if (arr[j] > arr[j+1]) {
                    var ls = arr[j]
                    arr[j] = arr[j+1]
                    arr[j+1] = ls
                }
            }
        }
        return arr
    }

// 选择（假设选择第一个为最小值，循环与假设最小值比较交换，找到真正的最小值）时间复杂度O(n^2)
function qs3(arr){
    for(var i = 0 ; i < arr.length ; i ++) {
        var minIndex = i
        for(var j = i ; j < arr.length; j ++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j
            }
        }
        var ls = arr[minIndex]
        arr[minIndex] = arr[i]
        arr[i] = ls
    }
    return arr
}