js常用算法

1.判断一个字符串是“回文”类型，回文：形如‘abcba’、‘mamam’这种第一个与最后一个字符相同，第二个和倒数第二个字符相同。。。一次类推，该怎么实现呢？

对与我来说，首先看到第一眼，还真没想起来怎么处理，后来想到用reverse()就可以啊！MD！那是数组的方法！！！总之要用reverse()方法，那就先转成数组，再转成字符串来比较就行了啊

function checkReverseString(str) {  
    return str == str.split('').reverse().join('');
}

2.数组去重：
先来看用老方法处理：

1）.object对象中是否存在当前key

var arr = [1,2,3,1,2,3]
function uniqueArr(arr) {
    var obj = {}
    var result = []
    for (var i = 0, len = arr.length; i < len; i++) {
        if (!obj[arr[i]]) {
            obj[arr[i]] = true
            result.push(arr[i])
        }
    }
    return result
}

2) Array.indexOf()

var arr = [1,2,3,1,2,3]
function uniqueArr(arr) {
    var obj = arr
    var result = []
    for (var i = 0, len = arr.length; i < len; i++) {
        if (result.indexOf(arr[i]) === -1) {
            result.push(arr[i])
        }
    }
    return result
}

3) ES5 filter 

[1,1,2,2,3,'a','a'].filter(function(ele,index,array){
    return index === array.indexOf(ele)
})

indexOf(ele)检查到的是第一次遇到当前项的下标，我们看到数字1，出现了两次次，0位置和1位置，indexOf(1) 永远都等于0，所以1位置的1就不符合filter传入的规则，只返回0位置的1.

4）ES5 reduce（fn(), el, index, array）

[1,1,2,3].reduce((result, el, i, arr) => {
    if (i === arr.indexOf(el)) {
        result.push(el)
    }
    
    return result
}, [])

也是循环每一项，每一项的处理都在内部函数中处理。

5) ES6 Array.from(new Set())，set中不存在重复的项：

var arr = [1,2,3,1,2,3]
var arr1 = Array.from(new Set(arr))
console.log(arr1)

还是这种方法好啊，清清爽爽！

3.统计一个字符串中出现次数最多的字符和出现的次数

刚开始没有太多的思路，刚才数组去重，用到了obj key的属性，那这里是不是也可以用呢？遇到新的字符，obj的该字符的值设为1，再遇到就+1，来试试：

var str = 'aaaabbbc'
function maxSym(str) {
    if (str && str.length <= 1) {
        return str
    }
    var obj = {}
    for (var i = 0, len = str.length; i < len; i++) {
        obj[str[i]] = obj[str[i]] ? obj[str[i]] + 1 : 1
              // 这里只能写obj[str[i]] + 1,其他写法，例如++,执行会有问题，如果你知道为什么请告诉我
    }
    var maxStr = ''
    var maxCount = 0
    for (var key in obj) {
        if (obj[key] > maxCount) {
            maxStr = key
            maxCount = obj[key]
        }
    }
    return maxStr + ':' + maxCount
}
console.log(maxSym(str))

4.不愿意看到的排序，还是要来的

1).先看看冒泡排序，必须要掌握

var arr = [2,34,4,1]
function bubbleSort(arr) {
    if (arr && arr.length <= 1) {
        return arr
    }
    for (var i = 0, len = arr.length; i < len - 1; i ++) { // 控制循环的轮数，为什么要len - 1?要比较有两个元素的数组[2,1]，请问比较几轮？1轮！以此类推:len-1
        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
            }
        }
        console.log(arr)
    }
    return arr
}
console.log(bubbleSort(arr))

2). 选择排序：

和冒泡排序原理差不多，但不是两两比较，立即换位置，而是执行完一轮，再互换位置：

[3,4,5,1,7]，假设第0位3是最小的数，与后一位比较3 < 4，再往后 3 < 5, 再往后 3 > 1, 到这里，最小的数的位置应该变成第3位，把这个位置记下来，然后继续往后比较 1 < 7,到这里就比较结束了，现在需要互换位置了，现在最小的数的位置在第3位，应该转换成[1,4,5,3,7]，也就是“假定最小的”和真实最小的互换位置。第0位已经是最小的数了。第二轮，从第1位开始算起，以此类推，完成排序

function selectionSort(arr) {
    var len = arr.length, min;
    for (var i = 0; i < len; i ++) {
        min = i // 假定第i轮循环的第一个数最小，把这个位置保存起来
        for (var j = i + 1; j < len; j ++) {
            if (arr[j] < arr[min]) {
                min = j // 如果后面有更小的数，把这个位置记为最小
            }
        }
        if (i != min) { // 如果后面有更小的数，第i轮第一个数要和更小的数互换位置
            var temp = arr[min]
            arr[min] = arr[i]
            arr[i] = temp 
        }
    }
    return arr
}
var arr = [3,4,5,1,7]
console.log(selectionSort(arr))

过程： 

[3,4,5,1,7] => [1,4,5,3,7] => [1,3,5,4,7] => [1,3,4,5,7] => [1,3,4,5,7]

3).插值排序：(斗地主的时候，左手里面的牌，是不是排好序的？右手随意起牌，差到左手里已经排好序的牌中，这个过程就是插值排序)

function inputSort(data)  {  
    var temp; 
    for (var i = 1; i < data.length; i++) {  
        for(var j = i; (j > 0) && (data[j] < data[j - 1]); j--) {  
            temp = data[j]; 
            data[j] = data[j - 1]
            data[j - 1] = temp
        }
    }
    return data
}
var arr = [4,3,2,5,1]
console.log(inputSort(arr))

4）合并排序，MD，老菜鸟，写不动了，先到这里，让我好好理解一下

 归并排序，采用了‘分’，分而治之，然后再合。

// 先看把两个有序数组合并
function merge(left, right) {
    var result = []
    while (left.length > 0 && right.length > 0) {
        if (left[0] < right[0]) { // 左边数组的第一个数值，小于右边数组第一个数值
            result.push(left.shift()) // 把左边数组第一个数值取出来，并添加到result中
        } else {
            result.push(right.shift()) // 否则把右边数组第一个数值取出来，并添加到result中
        }
    }
    // 比如 left = [1, 2] right = [3, 4] ,
    // 只发生两次比较,第一次： 1 < 3 , result = [1]
    // 第二次： 2 < 3 , result = [1, 2]
    // 这个时候left已经空了，length => 0 , 所以while 循环结束，但是right = [3, 4]
    // 当然也可能是right先变成[],
    // 所以要把result、left和right拼接在一起返回，得到最终结果
    return result.concat(left, right)
}

// 这里的主要功能是拆分数组，至少拆成两个数组，才能使用merge方法，所以使用递归，一直拆下去，
// 当数组的长度小于等于1的时候，终止递归拆分，执行merge操作，并返回merge后的结果
// 递归调用的逻辑，可能会比较绕，多理解一下，还是没大问题的！加油！

function mergeSort(arr) {
    if (arr.length <= 1) {
        return arr
    }
    var middle = Math.floor(arr.length / 2) // 取中间序列号
    var left = arr.slice(0, middle) // 取中间序列号之前的部分，赋值给left
    var right = arr.slice(middle) // 取中间序列号之后的部分，赋值给right
    return merge(mergeSort(left), mergeSort(right)) // 执行merge操作，其实这里面是先把大数组递归拆成单元素数组，再merge
}

var arr = [3,1,4,2,6]
console.log(mergeSort(arr))

结果：

 

5).快速排序，先找到一个中间值，然后遍历，把比中间值小的放在左边数组，把比中间值大的放在右边数组，然后再分别按这种思路对两个新数组比较，以此类推，直到结束。

var arr = [2,34,3,4]
function quickSort(arr) {
    if (arr && arr.length <= 1) {
        return arr
    }
    var midEl = arr[0] // 
    var left = []
    var right = []
    for (var i = 1, len = arr.length; i < len; i++) {
        if (arr[i] < midEl) { 
            left.push(arr[i]) // 比第一个数小的数放在左边
        } else {
            right.push(arr[i]) 
        }
    }
    return quickSort(left).concat([midEl], quickSort(right))
}
console.log(quickSort(arr))
这种方式会额外增加两个数组，空间复杂度高，下面说一个更节省空间的写法，必须掌握。

function quickSort(arr) {
    if (arr.length <= 1) { // 数组长度为1时，默认数组有序
        return arr
    }

    let flag = arr[0] // 取第0个元素为 中间值（当然你可以随便取，比如取最后一个）
    let i = 1 // 令左边指针初始化为1
    let j = arr.length - 1 // 令右边指针初始化为 数组长度-1

    while(i < j) { // 如果左指针还小于又指针，则继续判断
        while(arr[j] >= flag && i < j) { // 如果 右边 的数大于 flag ， 不做操作，继续左移，因为大数本来就该在右边
            j--
        }
        while(arr[i] <= flag && i < j) { // 如果 左边 的数小于 flag， 不做操作，继续右移，因为小数本来就该在左边
            i++
        }
        let temp = arr[j] // 如果不满足上面两个条件，也就是说，左边出现了大数，且右边出现了小数，则执行交换
        arr[j] = arr[i]
        arr[i] = temp
    }
    let temp = arr[0] // 最后调换 中间值 与 右指针（也是左指针，因为此时左右指针索引相等），到此第一次遍排序结束
    arr[0] = arr[j]
    arr[j] = temp
    return quickSort(arr.slice(0,i)).concat([flag]).concat(quickSort(arr.slice(j+1))) // 递归调用即可实现整体排序
}
var a = [13,1,3,45,2,56,6,10]
var b = quickSort(a)
console.log(b)

 

结果：

 5、递归：求和问题、(待补充其他类型)

function fn(n) {
    if (n === 1) return 1
    return n + fn(n - 1)
}

　function fn(n) {
　　return n && n + fn(n - 1)
　}

fn(5) // 15

6、产生斐波那契数列，并用canvas画图，[0, 1, 1, 2, 3, 5, 8, 13, 21, 34...],数组中的每一项当做圆的半径，每次画1/4圆。

var canvas = document.getElementsByTagName('canvas')[0]
canvas.width = 600
canvas.height = 480
var ctx = canvas.getContext('2d')
var coor = {x: 300, y: 240}
function draw(r1, n, r2) { // r1-前一个圆的半径，n-数组下标,r2-下标圆的半径
    var r = r2 * 5 // 半径太小，放大5倍
    var startAngle = Math.PI // 起始角
    var endAngle = Math.PI * 0.5 // 终止角
    var antiClockWise = true // 逆时针方向
　　// 两内切圆满足的条件： 1、两圆的圆心距d，等于大圆的半径r2减去小圆的半径r1，即： d = r2 - r1.
　　// 依据上述条件，可以得出下一个圆的圆心坐标：注意，下一个圆的坐标值，有一个值和当前圆的一致，因为无论哪种情况，两圆心都会在一条直线上。
　　// 所以有一下结论： x2 = x1 +(-) d;y2 = y1 +(-) d => x2 = x1 +(-) (r2 - r1);y2 = y1 +(-) (r2 - r1)

    if (n > 2) {
        switch(n % 4) {
            case 0: // n = 4、8、12...第一象限
            coor.x = coor.x - (r - (r1 * 5)) // 这里刚开始会比较难理解，注意对照上面的推导关系，会好理解一些. *5 是因为r = r2 * 5,所以
　　　　　　　　　　　　　　　　　　　　　　　　　　　// r1也放大5倍
            startAngle = 0
            endAngle = Math.PI * 1.5
            break;
            case 1: // n = 5、9、13...第二象限
            coor.y = coor.y + (r - (r1 * 5))
            startAngle = Math.PI * 1.5
            endAngle = Math.PI
            break;
            case 2: // n = 6、10、14...第三象限
            coor.x = coor.x + (r - (r1 * 5))
            startAngle = Math.PI
            endAngle = Math.PI * 0.5
            break;
            case 3: // n = 3、7、11...第四象限
            coor.y = coor.y - (r - (r1 * 5))
            startAngle = Math.PI * 0.5
            endAngle = 0
            break;
        }
    }
    ctx.beginPath()
    ctx.arc(coor.x, coor.y, r, startAngle, endAngle, antiClockWise)
    ctx.lineWidth = 3
    ctx.strokeStyle = "#f34e56"
    ctx.stroke()
}

function getFibonacci(n) {
    var i = 0
    var arr = []
    while(i < n) {
        if (i <= 1) {
            arr.push(i)
        } else {
            arr.push(arr[i - 2] + arr[i - 1]) // arr[i] = arr[i - 2] + arr[i - 1] 
        }
        i++
    }
    return arr
}
var arrFibonacci = getFibonacci(10)
console.log(arrFibonacci)
for (var j = 0; j < arrFibonacci.length; j++) {
    if (j >= 2) { // 数组长度至少为3，才满足斐波那契数组定义
        draw(arrFibonacci[j - 1], j, arrFibonacci[j])
    }
}

结果如图：

7、合并两个有序数组：

var a = [2,4,6], b = [1,3]
function two(left = [], right = []) {
    var result = []
    while(left.length && right.length) {
        result.push(left[0] <= right[0] ? left.shift() : right.shift())
    }
    return result.concat(left, right)
}