找回密码
当前位置：前端开发者 > JavaScript > 正文

前端开发js常用算法

2018-11-29 分类：JavaScript 阅读(671) 评论(0)
前端开发 浏览器 编辑
前端开发 浏览器兼容性
前端开发中谷歌浏览器

冒泡排序：依次比较相邻的两个数，将小数放在前面，大数放在后面
效率：n(n-1)/2
javascript 代码

var tempArr = [5, 4, 3, 2, 7, 8, 6, 1, 9, 10]
function bubble(arr) {
    var l = arr.length
    var obj = { time: 0 } //遍历次数
    for (var i = 0; i < l – 1; i++) {
        for (var j = i + 1; j < l; j++) {
            if (arr[i] > arr[j]) {
                var temp = arr[j]
                arr[j] = arr[i]
                arr[i] = temp
            }
            obj.time++
        }
    }
    obj.arr = arr
    return obj
}
console.log(bubble(tempArr))

快速排序：首先在数组中找到一个基准值（一般为数组中间的值），然后遍历数组中的元素，小于基准值的放到左边数组，大于基准值的放到数组右边，递归以上过程，直到最后数组的长度为1。
效率：比冒泡排序快，不太稳定。

javascript 代码

var tempArr = [5, 4, 3, 2, 7, 8, 6, 1, 9, 10]
var time = 0
function quickSort(arr) {
    if (arr.length <= 1) return arr
    var la = []
    var ra = []
    var cIndex = Math.floor(arr.length / 2) //基准值索引
    var cValue = arr.splice(cIndex, 1) //基准值
    for (var i = 0, l = arr.length; i < l; i++) {
        if (arr[i] > cValue) {
            ra.push(arr[i])
        } else {
            la.push(arr[i])
        }
        time++
    }
    return quickSort(la).concat(cValue, quickSort(ra))
}
console.log(quickSort(tempArr))
console.log(time)

判断字符串出现最多的字符并统计次数
javascript 代码

var tempStr = ‘asdfsdfkjkwernnsfasdfsfsafsff’
function countStr(str) {
    var obj = {}
    for (var i = 0, l = str.length; i < l; i++) {
        if (obj.hasOwnProperty(str[i])) {
            obj[str[i]]++
        } else {
            obj[str[i]] = 1
        }
    }
    return obj
}
console.log(countStr(tempStr))

数组去重方法一（也可以用ES6 的includes（返回boolean） 代替indexOf）
javascript 代码

var arr1 = [
    1,
    2,
    3,
    11,
    2,
    3,
    ’11’,
    ’11’,
    ’11’,
    ’11’,
    ’11’,
    ‘2’,
    ‘1’,
    ’11’,
    ‘6’,
    { a: 1 },
    { a: 1 },
    [1],
    [1],
]
var unique1 = function(arr) {
    //返回新数组
    var temp = []
    for (var i = 0; i < arr.length; i++) {
        if (temp.indexOf(arr[i]) === -1) {
            temp.push(arr[i])
        }
    }
    return temp
}
console.log(unique1(arr1))

数组去重方法二
javascript 代码

var arr2 = [
    1,
    2,
    3,
    11,
    2,
    3,
    ’11’,
    ’11’,
    ’11’,
    ’11’,
    ’11’,
    ‘2’,
    ‘1’,
    ’11’,
    ‘6’,
    { a: 1 },
    { a: 1 },
    [1],
    [1],
]
var unique2 = function(arr) {
    //修改原来数组
    for (var i = 0; i < arr.length – 1; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j]) {
                arr.splice(j, 1)
                j–
            }
        }
    }
    return arr
}
console.log(unique2(arr2))

数组去重方法三
javascript 代码

var arr3 = [
    1,
    2,
    3,
    11,
    2,
    3,
    ’11’,
    ’11’,
    ’11’,
    ’11’,
    ’11’,
    ‘2’,
    ‘1’,
    ’11’,
    ‘6’,
    { a: 1 },
    { a: 1 },
    [1],
    [1],
]
var unique3 = function(arr) {
    //直接修改原来数组
    arr.sort()
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] === arr[i + 1]) {
            arr.splice(i + 1, 1)
            i–
        }
    }
    return arr
}
console.log(unique3(arr3))

统计字符出现的位置
javascript 代码

function appear(str, str_target) {
    var n = 0
    var result = []
    while (str.indexOf(str_target, n) > -1) {
        result.push(str.indexOf(str_target, n))
        n = str.indexOf(str_target, n) + str_target.length
    }
    return result
}
console.log(appear(‘abascbascbabasbascbascascbab’, ‘ab’))

判断是否是质数
javascript 代码

function isPrime(number) {
    if (typeof number !== ‘number’ || number < 2) {
        // 不是数字或者数字小于2
        return false
    }
    if (number === 2) {
        //2是质数
        return true
    } else if (number % 2 === 0) {
        //排除偶数
        return false
    }
    var squareRoot = Math.sqrt(number) //因为2已经验证过，所以从3开始；且已经排除偶数，所以每次加2
    for (var i = 3; i <= squareRoot; i += 2) {
        if (number % i === 0) {
            return false
        }
    }
    return true
}
console.log(isPrime(2))
console.log(isPrime(3))
console.log(isPrime(9))
做前端开发浏览器
前端开发苹果浏览器滚动条
前端开发考虑的主流浏览器
赞(0)
64K
标签：前端开发者

前端开发者

相关推荐

评论 抢沙发

评论前必须登录！

 

最新评论