JS幾種常見算法

1、冒泡排序

1.1 冒泡排序原理

• 一、比較相鄰的兩個元素，若是前一個比後一個大，則交換位置。
• 二、第一輪的時候最後一個元素應該是最大的一個。
• 三、按照步驟一的方法進行相鄰兩個元素的比較，這個時候因爲最後一個元素已是最大的了，因此最後一個元素不用比較。

1.2 冒泡排序實例

var exampleArr = [8, 94, 15, 88, 55, 76, 21, 39];
function sortArrByBubble(arr) {
    for (i = 0; i < arr.length - 1; i++) {
        for (j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
sortArrByBubble(exampleArr);
console.log(exampleArr);
複製代碼

2、二路歸併排序

2.一、 二路歸併排序原理

• 二路歸併排序主要運用了「分治算法」。
• 分治算法就是將一個大的問題劃分爲n個規模較小而結構類似的子問題。
• 這些子問題解決的方法都是相似的，解決掉這些小的問題以後，歸併子問題的結果，就獲得了「大」問題的解。

2.二、 二路歸併的理解

二路歸併排序主旨是「分解」與「歸併」

分解：  

• 一、將一個數組分紅兩個數組，分別對兩個數組進行排序。

• 二、循環第一步，直到劃分出來的「小數組」只包含一個元素，只有一個元素的數組默認爲已經排好序。

歸併：

• 1.將兩個有序的數組合併到一個大的數組中。
• 2.從最小的只包含一個元素的數組開始兩兩合併。此時，合併好的數組也是有序的

2.3 二路歸併的理解

2.4 二路歸併實例

function mergeSort(arr) {
    // 設置終止的條件，
    if (arr.length < 2) {
        return arr;
    }
    //設立中間值
    var middle = parseInt(arr.length / 2);
    //第1個和middle個之間爲左子列
    var left = arr.slice(0, middle);
    //第middle+1到最後爲右子列
    var right = arr.slice(middle);
    if (left == "undefined" && right == "undefined") {
        return false;
    }
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
    var result = [];

    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            //把left的左子樹推出一個，而後push進result數組裏
            result.push(left.shift());
        } else {
            //把right的右子樹推出一個，而後push進result數組裏
            result.push(right.shift());
        }
    }
    //通過上面一次循環，只能左子列或右子列一個不爲空，或者都爲空
    while (left.length) {
        result.push(left.shift());
    }
    while (right.length) {
        result.push(right.shift());
    }
    return result;
}
// 測試數據
var nums = [6, 1, 4, 8, 2, 7, 3, 5];
console.log(mergeSort(nums))
複製代碼

3、斐波那契數列

3.1 斐波那契數列

• 斐波那契數列（Fibonaccisequence），又稱黃金分割數列、因數學家列昂納多·斐波那契（LeonardodaFibonacci）以兔子繁殖爲例子而引入，故又稱爲「兔子數列」
• 指的是這樣一個數列：一、一、二、三、五、八、1三、2一、3四、……
• 在數學上，斐波納契數列以以下被以遞歸的方法定義：
• F(0)=1，F(1)=1, F(n)=F(n-1)+F(n-2)（n>2，n∈N*）

3.2 斐波那契數列 實例

function Fibonacci(n) {
    if (n <= 1) {
        return 1
    }
    return Fibonacci(n - 1) + Fibonacci(n - 2);
}
console.log(Fibonacci(8))

// 輸出結果34
複製代碼

4、二分查找

4.一、什麼是二分查找

二分法查找，也稱折半查找，是一種在有序數組中查找特定元素的搜索算法。 查找過程能夠分爲如下步驟：

• 一、首先，從有序數組的中間的元素開始搜索，若是該元素正好是目標元素（即要查找的元素），則搜索過程結束，不然進行下一步。
• 二、若是目標元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半區域查找，而後重複第一步的操做。
• 三、若是某一步數組爲空，則表示找不到目標元素。

4.二、二分查找實例

非遞歸算法

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 23, 44, 86];

function binarySearch(arr, key) {
    var low = 0,
        high = arr.length - 1;
    while (low <= high) {
        var mid = parseInt((high + low) / 2);
        if (key == arr[mid]) {
            return mid;
        } else if (key > arr[mid]) {
            low = mid + 1;
        } else if (key < arr[mid]) {
            high = mid - 1;
        } else {
            return -1;
        }
    }
};
var result = binarySearch(arr, 10);
console.log(result); // 9 返回目標元素的索引值   

複製代碼

遞歸算法

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 23, 44, 86];

function binarySearch(arr, low, high, key) {
    if (low > high) {
        return -1;
    }
    var mid = parseInt((high + low) / 2);
    if (arr[mid] == key) {
        return mid;
    } else if (arr[mid] > key) {
        high = mid - 1;
        return binarySearch(arr, low, high, key);
    } else if (arr[mid] < key) {
        low = mid + 1;
        return binarySearch(arr, low, high, key);
    }
};

var result = binarySearch(arr, 0, 13, 10);
console.log(result); // 9 返回目標元素的索引值
複製代碼