前端开发应该掌握的查找算法

前端开发人员在平时项目开发过程中查找算法应该是使用频率最高的算法之一，因此我们掌握一些常见的查找算法是很有必要的，掌握这些算法不仅能提高我们的开发工作效率，好的算法实现还能在一定程度上提升项目性能，同时也能提升我们的编程思维能力。

那么常见的查找算法有哪些呢？

线性查找
二分查找
插值查找
哈希查找
二叉搜索树查找
AVL树、红黑树、B树/B+树查找
总结

线性查找

线性查找（Linear Search）是一种简单直观的查找算法，适用于无序的数据集合。它通过逐个比较查找目标，直到找到目标元素或遍历完整个数据集合。

实现原理：

从数据集合的第一个元素开始，逐个与目标元素进行比较。
如果找到了匹配的元素，返回该元素的索引。
如果遍历完整个数据集合都没有找到匹配的元素，返回-1表示查找失败。

示例代码和注释如下：

// 线性查找算法
function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i; // 返回匹配元素的索引
    }
  }
  return -1; // 没有找到匹配元素，返回-1
}

// 示例用法
const arr = [5, 8, 2, 10, 3];
const target = 10;
const index = linearSearch(arr, target);
console.log(index); // 输出：3

使用场景：
线性查找适用于简单的无序数据集合，或者数据集合规模较小的情况。它不需要数据集合有特定的排序方式，可以直接遍历查找目标元素。线性查找的优点是简单易懂，实现简单，对于小规模数据集合的查找是有效的。然而，对于大规模数据集合，线性查找的效率相对较低，因为它的时间复杂度为O(n)，需要逐个比较所有元素。在需要频繁进行查找操作、数据集合较大且有序的情况下，可以考虑使用其他更高效的查找算法，如二分查找或哈希查找。

二分查找

二分查找（Binary Search）是一种高效的查找算法，适用于有序的数据集合。它通过将查找范围分成两半，并与目标元素进行比较，从而快速定位目标元素的位置。

实现原理：

确定查找范围的起始位置（通常是数组的起始位置和结束位置）。
计算查找范围的中间位置。
将中间位置的元素与目标元素进行比较。
如果中间位置的元素与目标元素相等，表示找到目标元素，返回中间位置的索引。
如果中间位置的元素大于目标元素，缩小查找范围为左半部分，继续执行步骤2。
如果中间位置的元素小于目标元素，缩小查找范围为右半部分，继续执行步骤2。
如果查找范围缩小到起始位置大于结束位置，表示未找到目标元素，返回-1表示查找失败。

示例代码和注释如下：

// 二分查找算法
function binarySearch(arr, target) {
  let start = 0; // 起始位置
  let end = arr.length - 1; // 结束位置

  while (start <= end) {
    let mid = Math.floor((start + end) / 2); // 中间位置

    if (arr[mid] === target) {
      return mid; // 找到目标元素，返回索引
    } else if (arr[mid] > target) {
      end = mid - 1; // 缩小查找范围为左半部分
    } else {
      start = mid + 1; // 缩小查找范围为右半部分
    }
  }

  return -1; // 未找到目标元素，返回-1
}

// 示例用法
const arr = [2, 5, 8, 10, 15];
const target = 8;
const index = binarySearch(arr, target);
console.log(index); // 输出：2

使用场景：
二分查找适用于有序的数据集合。相较于线性查找，二分查找具有更高的效率，因为它通过将查找范围缩小一半来迅速定位目标元素。二分查找的时间复杂度为O(log n)。使用二分查找的前提是数据集合已经有序，因此适用于静态数据集合或者很少变动的数据集合。常见的使用场景包括查找有序数组、在数据库索引中进行查找、在字典或词汇表中进行查找等。然而，二分查找的局限是要求数据集合必须有序，如果数据集合频繁变动，插入和删除元素时需要维持有序性，可能会导致插入和删除操作的效率下降。

插值查找

插值查找（Interpolation Search）是一种优化的查找算法，特别适用于有序且均匀分布的数据集合。它通过估算目标元素所在的位置，从而更快地定位目标元素。

实现原理：

确定查找范围的起始位置和结束位置。
根据目标元素的估算位置，计算出一个估算索引（插值公式）。
比较估算索引处的元素与目标元素的大小关系。
如果估算索引处的元素等于目标元素，表示找到目标元素，返回估算索引。
如果估算索引处的元素大于目标元素，缩小查找范围为估算索引的左侧，继续执行步骤2。
如果估算索引处的元素小于目标元素，缩小查找范围为估算索引的右侧，继续执行步骤2。
如果查找范围缩小到起始位置大于结束位置，表示未找到目标元素，返回-1表示查找失败。

示例代码和注释如下：

// 插值查找算法
function interpolationSearch(arr, target) {
  let start = 0; // 起始位置
  let end = arr.length - 1; // 结束位置

  while (start <= end && target >= arr[start] && target <= arr[end]) {
    // 根据目标元素的估算位置计算估算索引
    let pos = start + Math.floor(((target - arr[start]) / (arr[end] - arr[start])) * (end - start));

    if (arr[pos] === target) {
      return pos; // 找到目标元素，返回索引
    } else if (arr[pos] < target) {
      start = pos + 1; // 缩小查找范围为估算索引的右侧
    } else {
      end = pos - 1; // 缩小查找范围为估算索引的左侧
    }
  }

  return -1; // 未找到目标元素，返回-1
}

// 示例用法
const arr = [2, 5, 8, 10, 15];
const target = 8;
const index = interpolationSearch(arr, target);
console.log(index); // 输出：2

使用场景：
插值查找适用于有序且均匀分布的数据集合。相较于二分查找，插值查找通过更精准地估算目标元素的位置，可以在有序数据集合中更快地定位目标元素。插值查找的时间复杂度平均情况下为O(log log n)，最坏情况下为O(n)，但通常情况下比二分查找效率更高。使用插值查找的前提是数据集合有序且分布均匀，这样才能更准确地估算目标元素的位置。常见的使用场景包括有序数组的查找和索引、数值范围查找等。然而，插值查找的局限性在于对于分布不均匀的数据集合，可能导致查找性能的下降，甚至无法达到预期的效果。因此，在选择插值查找算法时，需要根据数据集合的特点进行评估。

哈希查找

哈希查找（Hash Search）是一种基于哈希表的查找算法，通过将元素映射到哈希表中的索引位置来进行查找。哈希查找具有快速的查找速度，适用于大规模数据集合和需要频繁查找的场景。

使用函数实现哈希查找算法

实现原理：

创建一个哈希表（也可以使用JavaScript中的对象来模拟哈希表）。
遍历数据集合，将每个元素通过哈希函数映射到哈希表的索引位置，并将元素存储在该位置。
当需要查找目标元素时，将目标元素通过哈希函数计算出对应的索引位置。
在哈希表中检查该索引位置是否存在元素，如果存在且与目标元素相等，则表示找到目标元素。
如果哈希表中的该索引位置没有元素，或者存在元素但不等于目标元素，则表示未找到目标元素。

示例代码和注释如下：

// 使用函数哈希查找算法
function hashSearch(arr, target) {
  const hashTable = {}; // 哈希表

  // 构建哈希表
  for (let i = 0; i < arr.length; i++) {
    hashTable[arr[i]] = i;
  }

  // 查找目标元素
  if (hashTable.hasOwnProperty(target)) {
    return hashTable[target]; // 找到目标元素，返回索引
  }

  return -1; // 未找到目标元素，返回-1
}

// 示例用法
const arr = [5, 8, 2, 10, 3];
const target = 10;
const index = hashSearch(arr, target);
console.log(index); // 输出：3  注意：该实现如果有重复数据，则会取最后一个元素的索引

使用类实现哈希查找算法

实现原理：

创建一个哈希表，用于存储数据。
定义一个哈希函数，它将键映射为哈希值，该哈希值表示键的存储位置。
将键值对插入到哈希表中，根据哈希函数计算键的哈希值，并将值存储在对应的哈希位置。
当需要查找键对应的值时，使用哈希函数计算键的哈希值，然后在哈希表中查找对应的存储位置，获取值。

// 使用类实现哈希查找算法
class HashTable {
  constructor() {
    this.table = {}; // 哈希表，用对象表示
  }

  // 哈希函数，将键转换为哈希值
  hash(key) {
    let hashValue = 0;
    for (let i = 0; i < key.length; i++) {
      hashValue += key.charCodeAt(i);
    }
    return hashValue % 37; // 取余数作为哈希值
  }

  // 插入键值对到哈希表中
  insert(key, value) {
    const index = this.hash(key);
    this.table[index] = value;
  }

  // 根据键查找值
  search(key) {
    const index = this.hash(key);
    return this.table[index];
  }
}

// 示例用法
const hashTable = new HashTable();
hashTable.insert("apple", "red");
hashTable.insert("banana", "yellow");
const value = hashTable.search("apple");
console.log(value); // 输出：red  注意：该实现如果有重复插入数据，则会取最后一个元素

使用场景：
哈希查找适用于大规模数据集合和需要频繁查找的场景。它的查找速度快，平均情况下的时间复杂度为O(1)，即常数时间。哈希查找在处理海量数据时具有较高的效率，适合用于数据库索引、缓存系统、字典等需要快速查找的场景。然而，哈希查找也有一些局限性，如哈希函数设计不当可能导致哈希冲突，需要解决冲突的方法（如链表法或开放地址法），并且哈希表需要额外的空间来存储元素。另外，哈希查找对数据集合的有序性没有要求，适用于无序数据集合。因此，在选择哈希查找算法时，需要根据实际应用场景综合考虑。

二叉搜索树

二叉搜索树（Binary Search Tree，BST）是一种常用的数据结构，具有高效的查找操作。它满足以下性质：

每个节点最多有两个子节点，称为左子节点和右子节点。
左子节点的值小于父节点的值，右子节点的值大于父节点的值。
对于每个节点，其左子树中的所有节点值都小于该节点的值，右子树中的所有节点值都大于该节点的值。

实现原理：

创建一个二叉搜索树，并初始化为空树。
将第一个元素作为根节点插入到树中。
对于要插入的新元素，从根节点开始比较其值与当前节点的值的大小关系。
如果新元素的值小于当前节点的值，则将其插入到当前节点的左子树中。
如果新元素的值大于当前节点的值，则将其插入到当前节点的右子树中。
重复步骤3-5，直到找到合适的插入位置（即遇到空节点）。
查找元素时，从根节点开始比较要查找的元素与当前节点的值的大小关系。
如果要查找的元素等于当前节点的值，则找到目标元素。
如果要查找的元素小于当前节点的值，则继续在当前节点的左子树中查找。
如果要查找的元素大于当前节点的值，则继续在当前节点的右子树中查找。
如果找到目标元素或遇到空节点，则结束查找。

示例代码和注释如下：

// 二叉搜索树节点类
class Node {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

// 二叉搜索树类
class BinarySearchTree {
  constructor() {
    this.root = null; // 根节点
  }

  // 插入元素
  insert(value) {
    const newNode = new Node(value); // 创建新节点

    // 如果根节点为空，则将新节点作为根节点
    if (this.root === null) {
      this.root = newNode;
    } else {
      this.insertNode(this.root, newNode); // 插入节点
    }
  }

  // 辅助函数：递归插入节点
  insertNode(node, newNode) {
    // 如果新节点的值小于当前节点的值，则将其插入到左子树中
    if (newNode.value < node.value) {
      if (node.left === null) {
        node.left = newNode;
      } else {
        this.insertNode(node.left, newNode);
      }
    }
    // 如果新节点的值大于当前节点的值，则将其插入到右子树中
    else {
      if (node.right === null) {
        node.right = newNode;
      } else {
        this.insertNode(node.right, newNode);
      }
    }
  }

 

 // 查找元素
  search(value) {
    return this.searchNode(this.root, value); // 从根节点开始查找
  }

  // 辅助函数：递归查找节点
  searchNode(node, value) {
    // 如果节点为空，表示未找到目标元素
    if (node === null) {
      return false;
    }
    // 如果目标元素等于当前节点的值，表示找到目标元素
    if (value === node.value) {
      return true;
    }
    // 如果目标元素小于当前节点的值，则继续在左子树中查找
    if (value < node.value) {
      return this.searchNode(node.left, value);
    }
    // 如果目标元素大于当前节点的值，则继续在右子树中查找
    else {
      return this.searchNode(node.right, value);
    }
  }
}

// 示例用法
const bst = new BinarySearchTree();
bst.insert(5);
bst.insert(8);
bst.insert(2);
bst.insert(10);
bst.insert(3);

console.log(bst.search(10)); // 输出：true
console.log(bst.search(7)); // 输出：false

使用场景：
二叉搜索树适用于需要快速查找和插入的情况，尤其在动态数据集合中，它具有较高的查找效率。二叉搜索树的查找、插入、删除的平均时间复杂度是 O(log n)，其中 n 是树中节点的数量。

常见的使用场景包括：

数据的动态插入和删除：二叉搜索树可以高效地插入和删除节点，保持树的有序性。
排序：通过对二叉搜索树进行中序遍历，可以得到有序的数据序列。
查找最大值和最小值：二叉搜索树的最左子节点是最小值，最右子节点是最大值。
区间查询：通过在二叉搜索树上进行范围查找，可以找到满足特定区间条件的节点。

请注意，二叉搜索树的性能受树的平衡程度影响，如果树过于倾斜，可能会导致查找性能下降，因此在实际使用时，需要考虑平衡二叉搜索树（如AVL树、红黑树等）来维持树的平衡性。

AVL树、红黑树、B树/B+树查找

AVL树、红黑树和B树/B+树都是常见的自平衡二叉搜索树，它们在处理大量数据和维护平衡性方面具有优势。

AVL树:
- AVL树是一种严格平衡的二叉搜索树，它通过在每个节点上维护一个平衡因子（左子树高度减去右子树高度）来保持平衡。
- 平衡因子的绝对值不能超过1，即每个节点的左子树和右子树的高度差不超过1。
- 插入和删除操作可能需要通过旋转操作来重新平衡树。
- AVL树适用于需要快速的查找和更新操作，并对树的平衡性要求较高的场景。
红黑树:
- 红黑树是一种近似平衡的二叉搜索树，它通过在每个节点上引入额外的颜色属性（红色或黑色）来保持平衡。
- 红黑树具有以下性质：
  1) 每个节点要么是红色，要么是黑色。
  2) 根节点是黑色。
  3) 每个叶子节点（NIL节点，空节点）是黑色。
  4) 如果一个节点是红色，则它的两个子节点都是黑色。
  5) 从任意节点到其每个叶子节点的路径上，包含相同数量的黑色节点。
- 红黑树通过颜色变换和旋转操作来保持平衡。
- 红黑树适用于需要高效的插入、删除和查找操作，并对树的平衡性要求适度的场景。
B树/B+树:
- B树和B+树是多路搜索树，每个节点可以包含多个键值和子节点。
- B树是一种平衡的树结构，它具有以下特点：
  1) 根节点至少有两个子节点。
  2) 每个中间节点（非叶子节点）都包含k个子节点和k-1个键值，其中t <= k <= 2t，t为最小度数。
  3) 所有叶子节点位于同一层级。
- B+树是B树的变种，它在B树的基础上做了一些优化：
  1) 所有的键值都在叶子节点中出现，中间节点只包含键值的副本。
  2) 叶子节点通过指针链接起来，形成一个有序链表。
- B树和B+树适用于大规模数据的索引结构，例如数据库和文件系统索引。

这些自平衡二叉搜索树都具有较好的平衡性能和高效的插入、删除和查找操作，但每种树在不同场景下具有不同的特点和适用性。在选择使用哪种树结构时，需要根据具体的应用需求和数据规模进行综合考虑。

AVL树、红黑树、B树/B+树查找这些工作当中基本用不到，而且实现起来比较复杂，了解即可。

总结

查找算法作为程序员编码开发中使用最多的一种算法，掌握像线性查找、二分查找、插值查找、哈希查找算法，基本可以覆盖平常开发中绝大多数场景了，至于最后章节提到AVL树、红黑树、B树/B+树等自平衡二叉搜索树，由于实现复杂度比较高，而且对性能要求特别高的场景才会使用到，因此大致了解即可，感兴趣的可以自行掌握。掌握JS中的常见的查找算法可以提高数据处理和查询的效率，优化算法和数据结构的实现，并解决各种实际问题，这对于开发人员来说是非常有用的技能。

本文由mdnice多平台发布

前端开发应该掌握的查找算法