js 算法

作者: Veycn | 来源:发表于2019-03-27 21:45 被阅读0次

数组去重

利用对象

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))
}

或者(如果indexOflastIndexOf前后查询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 = 0100^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
}

相关文章

  • 排序算法

    JS里排序算法的写法:

  • js统计对象的层数

    js算法统计对象的层数

  • js算法

    质数(素数): 在大于1的自然数中只能被1和自己整除 判断一个数是不是质数,基本思路:对正整数n,如果用2到√n之...

  • js算法

    排序算法 冒泡排序 快速排序 字符串操作 判断回文字符串 翻转字符串 反向遍历字符串 function reve...

  • js 算法

    数组去重 利用对象 利用ES6 冒泡排序 选择排序 其他数出现了偶数次,找其中两个只出现了一次的数字 或者(如果i...

  • JS算法

  • js算法

    如何最方便地把数组中已存在的指定的某一项放在第0位

  • JS算法——排序算法

    一:冒泡排序 冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两...

  • 【JS算法】回溯算法

    题目:全排列给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列输入:nums = [1,2,3] ...

  • 使用 crypto-js 对数据进行对称加密

    npm install crypto-js要用 AES 算法加密,首先我们要引入 crypto-js ,crypt...

网友评论

      本文标题:js 算法

      本文链接:https://www.haomeiwen.com/subject/hyctbqtx.html