js算法

冒泡排序

function sort(elements){
 for(var i=0;i<elements.length-1;i++){
  for(var j=0;j<elements.length-i-1;j++){
   if(elements[j]>elements[j+1]){
    var swap=elements[j];
    elements[j]=elements[j+1];
    elements[j+1]=swap;
   }
  }
 }
}
 
var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];
console.log('before: ' + elements);
sort(elements);
console.log(' after: ' + elements);
复制代码

快速排序

function  quickSort(elements){
    if (elements.length <= 1) { return elements; }
    var pivotIndex = Math.floor(elements.length / 2);
    var pivot = elements.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];
    for (var i = 0; i < elements.length; i++){
           if (elements[i] < pivot) {
            left.push(elements[i]);
            } else {
            right.push(elements[i]);
            }
    }
    return quickSort(left).concat([pivot], quickSort(right))
}
var elements=[5,6,2,1,3,8,7,1.2,5.5,4.5]
alert(quickSort(elements))
复制代码

插入排序

（1） 从第一个元素开始，该元素能够认为已经被排序。
（2） 取出下一个元素，在已经排序的元素序列中从后向前扫描。
（3） 若是该元素（已排序）大于新元素，将该元素移到下一位置。
（4） 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
（5）将新元素插入到下一位置中。
（6） 重复步骤2 (取出下一个元素，在已经排序的元素序列中从后向前扫描)。
function insertSort(arr) {
    var len = arr.length;
    var temp;
    for (var i = 1;i < len;i++){
        temp = arr[i]
        for (var j = i;j > 0 && temp < arr[j-1];j--){
            // 当前值和以前的每一个值进行比较，发现有比当前值小的值就进行从新赋值
            arr[j] = arr[j-1];
        }
        arr[j] = temp;
    }
    return arr;
}
var arr=[5,6,2,1,3,8,7,1.2,5.5,4.5]
alert(insertSort(elements))
复制代码

二分查找

解析：二分查找，也为折半查找。首先要找到一个中间值，经过与中间值比较，
大的放又，小的放在左边。再在两边中寻找中间值，持续以上操做，直到找到所在位置为止。
    function binarySearch(data,item,start,end){
        var end=end || data.length-1;
        var start=start || 0;
        var m=Math.floor((start+end)/2);
        if(item==data[m]){
            return m;
        }else if(item<data[m]){
            return binarySearch(data,item,start,m-1) //递归调用
        }else{
            return binarySearch(data,item,m+1,end);
        }
        return false;
    }
    var arr=[34,12,5,123,2,745,32,4];
    binary(arr,5);
复制代码

阶乘

闭包实现阶乘，因为内部arr存储告终果，效率会更高
var fn = (function () {
        var arr = [1, 1, 2]; // 第0位是占位，从第一位开始算起
        return function (n) {
            var res = arr[n]; // 由于内部引用了arr，并返回，致使arr一直在内存中
            if (res) {
                return res;
            } else {
                arr[n] = n * fn(n-1);
                return arr[n];
            }
        }
    })();
复制代码

递归实现阶乘
function fn(n) {
        if (n == 1) {
            return 1;
        }else if (n == 2) {
            return 2;
        }
        return n * fn (n-1);
    }
复制代码

实现裴波那契

闭包实现裴波那契数列
var fn = (function () {
        var arr = [0, 1, 1]; // 第0位是占位，从第一位开始算起
        return function (n) {
            var res = arr[n]; // 由于内部引用了arr，并返回，致使arr一直在内存中
            if (res) {
                return res;
            } else {
                arr[n] = fn(n-1) + fn(n-2);
                return arr[n];
            }
        }
    })();
复制代码

递归实现裴波那契
function fn(n) {
        if (n == 1 || n==2) {
            return 1;
        }
        return fn(n-1) + fn (n-2);
    }
复制代码

递推法实现裴波那契
function fn1(n) {
        var x = 1,
            y = 1,
            z = 0;
        if (n == 1 || n == 2) {
            return 1;
        }else {
            for (var i = 2; i < n; i++) {
                z = x + y;
                x = y;
                y = z;
            }
            
        }
        return z;
    }
复制代码