数组去重

利用对象

function unique(arr) {
    var len = arr.length
    var newArr = []
    var obj = {}
    for (var i = 0; i < len; i++){
        if( !obj[arr[i]] ){
            obj[arr[i]] = true
            newArr.push(arr[i])
        }
    }
    return newArr
}

利用ES6

[...new Set([1,5,3,2,6,4,1,7,8,5,4,6,9,3])]

冒泡排序

function BubbleSort(arr) {
    var len = arr.length
    for (var i = 0; i < len; i++){
        for (var j = 0; j < len - i - 1; j++){
            if(arr[j] > arr[j + 1]){
                var temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
    return arr
}

选择排序

function ChooseSort(arr) {
    var len = arr.length
    for (var i = 0; i < len; i++){
        var max = 0 // 假设第0个是最大的
        for (var j = 0; j < len - i; j++){ // 去找最大的那个元素， len - i 保证了已经就位的元素不会进入比较
            if(arr[j] > arr[max]){
                max = j
            }
        }
        var temp = arr[len - i - 1] // len - i - 1 永远是未排序元素中最大的元素的位置
        arr[len - i - 1] = arr[max]
        arr[max] = temp
    } 
    return arr
}

其他数出现了偶数次，找其中两个只出现了一次的数字

function appearOnce(arr) {
    // 一个数组，有两个数字只出现了一次， 其他的数字都出现了偶数次， 找出这两个数字
    var len = arr.length
    var res = []
    var obj = {}
    for (var i = 0; i < len; i++){
        if(obj[arr[i]]){
            obj[arr[i]] += 1
        } else {
            obj[arr[i]] = 1
        }
    }
    for (var prop in obj){
        if(obj[prop] === 1){
            res.push(prop)
        }
    }
    return res.map(item => Number(item))
}

或者(如果indexOf和lastIndexOf前后查询index相等， 说明只出现了一次)

function appearOnce(arr) {
    var len = arr.length;
    var res = []
    for (var i = 0; i < len; i++){
        if(arr.indexOf(arr[i]) === arr.lastIndexOf(arr[i])){
            res.push(arr[i])
        }
    }
    return res
}

其他数出现了偶数次， 找出唯一一个只出现了一次的数字

function findUnique(arr) {
    var len = arr.length
    var res = 0
    for (var i = 0; i < len; i++){
        res ^= arr[i]
    }
    return res
}

原理是： 二进制的数a， 连续两次异或同一个数b， 最后的结果是 a
3^2^3 => 011^010^011 = 010 且 0^n 都为n. 所以令初始值为0， 然后与数组中的所有元素进行一次异或运算， 最后剩下的结果就是那个唯一只出现了一次的数字。

打印矩阵

function printMatrix(arr) {
    var rowLen = arr.length
    var colLen = arr[0].length

    var maxRow = arr.length - 1
    var maxCol = arr[0].length - 1
    var minRow = 0
    var minCol = 0

    var nowRow = 0
    var nowCol = 0

    var res = []
    var direction = {
        RIGHT: {
            row: + 0,
            col: + 1
        },
        DOWN: {
            row: + 1,
            col: + 0
        },
        LEFT: {
            row: + 0,
            col: - 1
        },
        UP: {
            row: - 1,
            col: + 0
        }
    }
    var nowDirection = direction.RIGHT
    if (colLen === 1){  // [[1],[2],[3],[4]] 只有一列的情况
        for (var i = 0; i < rowLen; i++){
            res.push(arr[i][0])
        }
        return res
    }

    for (var i = 0; i < rowLen * colLen; i++){
        res.push(arr[nowRow][nowCol])
        nowCol += nowDirection.col
        nowRow += nowDirection.row
        if(nowDirection === direction.RIGHT && nowRow === minRow && nowCol === maxCol){
            // 向右 到达边界
            console.log('left');
            nowDirection = direction.DOWN
        } else if(nowDirection === direction.DOWN && nowRow === maxRow && nowCol === maxCol){
            // 向下 到达边界
            console.log('down');
            nowDirection = direction.LEFT
        } else if(nowDirection === direction.LEFT && nowRow === maxRow && nowCol === minCol){
            // 向左 到达边界
            console.log('up');
            nowDirection = direction.UP
        } else if(nowDirection === direction.UP && nowRow === minRow && nowCol === nowCol){
            // 向上 到达边界
            console.log('right');
            nowDirection = direction.RIGHT
        } else if(nowRow === minRow + 1 && nowCol === minCol){ // 一圈完毕， 回到左上角， 该转弯的地方, 缩小范围
            minRow ++
            minCol ++
            maxRow --
            maxCol --
            nowDirection = direction.RIGHT
        }
    }
    return res
}