1.三种排序--冒泡，选择排序，快排

var mm = [9, 5, 10, 2, 7, 6, 2]
// 冒泡排序 稳定 n的平方
function bubble(arr) {
    var temp
    for (var i = 0, length = arr.length; i < length; i++) {
        for (var j = 0; j < i; j++) {
            if (arr[i] < arr[j]) {
                temp = arr[i],
                    arr[i] = arr[j],
                    arr[j] = temp
            }
        }
    }
    return arr
}
// 选择排序 不稳定 n的方
/* 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
   从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
    重复第二步，直到所有元素均排序完毕。*/
function select_sort(arr) {
    var len = arr.length;
    var temp, minIndex;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        temp = arr[i],
            arr[i] = arr[minIndex],
            arr[minIndex] = temp
    }
    return arr
}
//快排 不稳定 平均时间复杂度：nlogn
function quickSort(arr) {
    if (arr.length <= 1) {
        return arr
    }
    var pivotIndex = Math.floor(arr.length / 2);
    var pivot = arr.splice(pivotIndex, 1)[0];
    var left = [],
        right = []
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return quickSort(left).concat(pivot, quickSort(right))
}

2.二分查找（非递归版本）

// 二分查找
function binarySearch(arr, key) {
    var low = 0,
        high = arr.length - 1;
    while (low <= high) {
        var mid = parseInt((low + high) / 2);
        if (key === arr[mid]) {
            return mid
        } else if (key > arr[mid]) {
            low = low + 1
        } else {
            high = high - 1
        }
    }
    return -1
}

3.链表反转

function reverse(nodeList) {
    var pNode = nodeList;
    var pPre = null;
    var pNext;
    while (pNode) {
        pNext = pNode.next;
        pNode.next = pPre;
        pPre = pNode
        pNode = pNext
    }
 return pPre;
}