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;
    }
複製代碼