/**
 * 选择排序，时间复杂度为O(N^2)
 */
function selectSort(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        let idxOfMinVal = i, curVal = arr[i];
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < curVal) {
                curVal = arr[j];
                idxOfMinVal = j;
            }
        }
        if (idxOfMinVal != i) {
            [arr[i], arr[idxOfMinVal]] = [arr[idxOfMinVal], arr[i]];
        }
    }
}

// test
const arr = new Array(10);
for (let i = 0; i < arr.length; i++) {
    arr[i] = Math.round(Math.random() * 90 + 10)
}
console.log(arr);
selectSort(arr);
console.log(arr);

/**
 * 冒泡排序，时间复杂度为O(N^2)
 */
function bubbleSort(arr) {
    for (i = arr.length - 1; i > 0; i--) {
        for (j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
}
// test
const arr = new Array(10);
for (let i = 0; i < arr.length; i++) {
    arr[i] = Math.round(Math.random() * 80 + 20)
}
console.log(arr);
bubbleSort(arr);
console.log(arr);

纯粹的递归版

/**
 * 单纯的进行递归操作效率及其低下，因为算法内部做了大量的重复计算，时间复杂度为O(2^n)
 */
function fibonacci(n) {
    if (n <= 1) {
        return n;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

带缓存的递归版

/**
 * 将计算好的结果缓存起来，这样可以避免重复计算，时间复杂度为O(n)
 */
const memory = [0, 1];
function fibonacci(n) {
    if (typeof memory[n] === 'number') {
        return memory[n];
    } else {
        const result = fibonacci(n - 1) + fibonacci(n - 2);
        memory[n] = result;
        return result;
    }
}

循环版

洗牌算法，用于随机打乱一个有限列表内的元素顺序，目前公认最好的洗牌算法就是Fisher-Yates算法，使用JavaScript实现Fisher-Yates算法对一个数组进行顺序打乱的代码如下.

/**
 * Fisher-Yates算法
 * 将数组元素的顺序原地打乱
 * 时间复杂度O(N)
 * @param {Array<any>} 数组
 */
function shuffle(arr) {
    for (let i = arr.length - 1; i > 0; i--) {
        const idx = Math.floor(Math.random() * (i + 1));
        const tmp = arr[i];
        arr[i] = arr[idx];
        arr[idx] = tmp; 
    }
}