记录几个前端笔/面试中常遇到的算法

记录几个前端笔面试中遇到的算法

1、冒泡排序

function bubble_sort(A) {
    var l = A.length
    for (var i = 0; i < l; i ++) {
        for (var j = 0; j < l - i - 1; j ++) {
            if(A[j] > A[j + 1]) {
                var temp = A[j]
                A[j] = A[j + 1]
                A[j + 1] = temp
            }
        }
    }
}

冒泡排序就比较简单了，时间复杂度O(n^2)

2、快速排序

function quick_sort(A, p = 0, r = A.length - 1) {
    if (p < r){
        var q = partation(A, p, r)
        quick_sort(A, p, q - 1)
        quick_sort(A, q + 1, r)
    }
}
function partation(A, p, r) {
    var x = A[r]
    var i = p - 1
    for (var j = p; j < r; j ++) {
        if (A[j] <= x) {
            i += 1
            var temp = A[i]
            A[i] = A[j]
            A[j] = temp
        }
    }
    A[r] = A[i + 1]
    A[i + 1] = x
    return i + 1
}

快速排序是很多面试官喜欢问的，也是比较常用的，时间复杂度O(nlg(n))

3、插入排序

function insert_sort(A) {
    for (var j = 1; j < A.length; j ++) {
        var key = A[j]
        var i = j - 1
        while (i >= 0 && A[i] > key) {
            A[i + 1] = A[i]
            i -= 1
        }
        A[i + 1] = key
    }
}

插入排序也比较简单，时间复杂度O(n^2)

4、堆排序（维护最大堆）

function max_heap(A, i) {
    var l = i * 2 + 1
    var r = (i + 1) * 2
    var largest = i
    var size = A.heapSize
    if(l < size && A[l] > A[i]) {
        largest = l
    }
    if (r < size && A[r] > A[largest]) {
        largest = r
    }
    if (largest !== i) {
        var temp = A[i]
        A[i] = A[largest]
        A[largest] = temp
        max_heap(A, largest)
    }
}
function build_heap(A) {
    var l = A.heapSize
    for (var i = l / 2 - 1; i >= 0; i --) {
        max_heap(A, i)
    }
}
function heap_sort(A) {
    var l = A.length
    A.__proto__.heapSize = A.length
    build_heap(A)
    for (var i = l - 1; i > 0; i --) {
        var temp = A[i]
        A[i] = A[0]
        A[0] = temp
        A.__proto__.heapSize -= 1
        max_heap(A, 0)
    }
}

堆排序是比较好的排序算法，时间复杂度最坏O(nlgn)

5、寻找第i小的值

function find_partation(A, p, r) {
var key = A[r]
    var i = p - 1
    for (var j = p; j <= r - 1; j ++) {
        if (A[j] < key) {
            i += 1
            var temp = A[i]
            A[i] = A[j]
            A[j] = temp
        }
    }
    A[r] = A[i + 1]
    A[i + 1] = key
    return i + 1
}

function twoPart_find(A, p, r, i) {
    if (p === r) {
        return A[p]
    }
    var q = find_partation(A, p, r)
    var k = q - p + 1
    if (i === k) {
        return A[q]
    } else if (i < k) {
        return twoPart_find(A, p, q - 1, i)
    } else {
        return twoPart_find(A, q + 1, r, i - k)
    }
}

这个算法其实有一部分跟快排是一样的，先进行划分，然后在一半里面递归寻找，时间复杂度O(nlgn)

6、二分查找

function twoPart_find(A, p, r, i) {
if (p === r) {
        return A[p]
    }
    var q = find_partation(A, p, r)
    var k = q - p + 1
    if (i === k) {
        return A[q]
    } else if (i < k) {
        return twoPart_find(A, p, q - 1, i)
    } else {
        return twoPart_find(A, q + 1, r, i - k)
    }
}

二分查找比较简单，因为是有序的数组，递归调用即可，时间复杂度O(lgn)

7、取两个数组的交集

function findSame(A, B) {
var Al = A.length
    var Bl = B.length
    var temp = [], result = []
    for(var i = 0; i < Al; i ++) {
        if (!temp[A[i]]) {
            temp[A[i]] = 1;
        }
    }
    for (var j = 0; j < Bl; j ++) {
        if (temp[B[j]]) {
            temp[B[j]] = 0
            result.push(B[j])
        }
    }
    return result
}

这个也比较简单，使用hash实现的，方法简单得益于js中可以直接给数组的某一下标赋值，在平时很多小伙伴不喜欢用hash计算，其实hash还是很好用的。方法实现了去重求交集。时间复杂度O(m+n)

先发这几个，之后进行补充…