JS几种常见算法-CSDN博客

一、冒泡排序

1.1 冒泡排序原理

1、比较相邻的两个元素，如果前一个比后一个大，则交换位置。
2、第一轮的时候最后一个元素应该是最大的一个。
3、按照步骤一的方法进行相邻两个元素的比较，这个时候由于最后一个元素已经是最大的了，所以最后一个元素不用比较。

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.1、二路归并排序原理

二路归并排序主要运用了“分治算法”。
分治算法就是将一个大的问题划分为n个规模较小而结构相似的子问题。
这些子问题解决的方法都是类似的，解决掉这些小的问题之后，归并子问题的结果，就得到了“大”问题的解。

2.2、二路归并的理解

二路归并排序主旨是“分解”与“归并”

分解：

1、将一个数组分成两个数组，分别对两个数组进行排序。
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.1 斐波那契数列

斐波那契数列（Fibonaccisequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（LeonardodaFibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”
指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
在数学上，斐波纳契数列以如下被以递归的方法定义：
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.1、什么是二分查找

二分法查找，也称折半查找，是一种在有序数组中查找特定元素的搜索算法。查找过程可以分为以下步骤：

1、首先，从有序数组的中间的元素开始搜索，如果该元素正好是目标元素（即要查找的元素），则搜索过程结束，否则进行下一步。
2、如果目标元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半区域查找，然后重复第一步的操作。
3、如果某一步数组为空，则表示找不到目标元素。

4.2、二分查找实例

非递归算法

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 返回目标元素的索引值
复制代码