Javascript常见算法详解

在JavaScript中，算法是处理数据、解决问题的重要工具。本文将详细介绍几种常见的JavaScript算法，包括排序算法、搜索算法、递归算法和图算法。每个算法都包含代码示例和详细解释。

一、排序算法

1. 冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法，通过重复遍历要排序的列表，比较相邻的元素并交换它们的位置来排序。

function bubbleSort(arr) {
    let n = arr.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90]));

解释：

• 外层循环控制遍历次数。
• 内层循环进行相邻元素的比较和交换。

2. 快速排序（Quick Sort）

快速排序是一种分治算法，通过选择一个“基准”元素将数组分成两部分，然后递归地对两部分进行排序。

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let pivot = arr[Math.floor(arr.length / 2)];
    let left = [];
    let right = [];
    for (let i = 0; i < arr.length; i++) {
        if (i !== Math.floor(arr.length / 2)) {
            arr[i] < pivot ? left.push(arr[i]) : right.push(arr[i]);
        }
    }
    return quickSort(left).concat(pivot, quickSort(right));
}

console.log(quickSort([64, 34, 25, 12, 22, 11, 90]));

解释：

• 选择中间元素作为基准。
• 将数组分为小于基准和大于基准的两部分。
• 递归地对两部分进行排序并合并。

二、搜索算法

1. 线性搜索（Linear Search）

线性搜索是一种最简单的搜索算法，从头到尾依次查找元素。

function linearSearch(arr, target) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === target) {
            return i;
        }
    }
    return -1;
}

console.log(linearSearch([64, 34, 25, 12, 22, 11, 90], 22));

解释：

• 遍历数组，逐个比较元素与目标值，找到目标值时返回其索引。

2. 二分搜索（Binary Search）

二分搜索适用于已排序的数组，通过逐步缩小查找范围来快速定位目标值。

function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;
    while (left <= right) {
        let mid = Math.floor((left + right) / 2);
        if (arr[mid] === target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

console.log(binarySearch([11, 12, 22, 25, 34, 64, 90], 22));

解释：

• 初始化左右边界。
• 计算中间索引，比较中间元素与目标值。
• 调整左右边界，缩小查找范围，直到找到目标值或查找范围为空。

三、递归算法

1. 斐波那契数列（Fibonacci Sequence）

斐波那契数列是一种递归算法，其中每个数等于前两个数之和。

function fibonacci(n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(fibonacci(10));

解释：

• 基本情况：n <= 1时，返回 n。
• 递归情况：返回 fibonacci(n - 1) + fibonacci(n - 2)。

2. 阶乘（Factorial）

阶乘是递归算法的另一例子，计算一个数的阶乘。

function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

console.log(factorial(5));

解释：

• 基本情况：n === 0时，返回 1。
• 递归情况：返回 n * factorial(n - 1)。

四、图算法

1. 深度优先搜索（Depth-First Search, DFS）

DFS是一种图遍历算法，沿着每一条分支尽可能深入再回溯。

function dfs(graph, start, visited = new Set()) {
    visited.add(start);
    console.log(start);
    for (let neighbor of graph[start]) {
        if (!visited.has(neighbor)) {
            dfs(graph, neighbor, visited);
        }
    }
}

const graph = {
    A: ['B', 'C'],
    B: ['A', 'D', 'E'],
    C: ['A', 'F'],
    D: ['B'],
    E: ['B', 'F'],
    F: ['C', 'E']
};

dfs(graph, 'A');

解释：

• 使用集合 visited跟踪访问过的节点。
• 递归地访问每个相邻节点。

2. 广度优先搜索（Breadth-First Search, BFS）

BFS是一种图遍历算法，逐层访问每一层的节点。

function bfs(graph, start) {
    let queue = [start];
    let visited = new Set([start]);
    while (queue.length > 0) {
        let node = queue.shift();
        console.log(node);
        for (let neighbor of graph[node]) {
            if (!visited.has(neighbor)) {
                visited.add(neighbor);
                queue.push(neighbor);
            }
        }
    }
}

const graph = {
    A: ['B', 'C'],
    B: ['A', 'D', 'E'],
    C: ['A', 'F'],
    D: ['B'],
    E: ['B', 'F'],
    F: ['C', 'E']
};

bfs(graph, 'A');

解释：

• 使用队列 queue逐层访问节点。
• 使用集合 visited跟踪访问过的节点。

思维导图

graph TB
A[排序算法] --> B[冒泡排序]
A --> C[快速排序]
D[搜索算法] --> E[线性搜索]
D --> F[二分搜索]
G[递归算法] --> H[斐波那契数列]
G --> I[阶乘]
J[图算法] --> K[深度优先搜索]
J --> L[广度优先搜索]

结论

本文介绍了几种常见的JavaScript算法，包括排序、搜索、递归和图算法。每种算法都提供了详细的代码示例和解释。通过理解这些算法，你可以在实际项目中有效地解决各种数据处理和分析问题。