一些在前端开发中常见的算法-查找算法

查找算法用于在数据集合中找到特定的元素。下面，我将逐步讲解几种常见的查找算法，包括线性查找、二分查找、跳表查找和哈希表查找。这些算法有不同的应用场景和效率。

1. 线性查找（Linear Search）

线性查找 是最基本的查找算法，它逐个检查每个元素，直到找到目标元素或遍历完整个集合。

步骤：

1. 从第一个元素开始：检查当前元素是否是目标元素。
2. 逐个比较：如果不是，则检查下一个元素。
3. 停止条件：找到目标元素则返回其位置；若遍历完整个集合仍未找到，则返回失败。

代码实现：

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i; // 返回目标元素的索引
    }
  }
  return -1; // 如果没有找到目标元素
}

// 示例
const array = [10, 20, 30, 40, 50];
console.log(linearSearch(array, 30)); // 输出: 2
console.log(linearSearch(array, 60)); // 输出: -1

2. 二分查找（Binary Search）

二分查找 是一种高效的查找算法，仅适用于已排序的数组。它通过不断将搜索范围减半来快速找到目标元素。

步骤：

1. 初始化搜索范围：设定初始的左边界和右边界。
2. 计算中间位置：计算当前搜索范围的中间位置。
3. 比较中间元素：
   • 如果中间元素等于目标元素，返回其位置。
   • 如果中间元素小于目标元素，更新左边界为中间位置的下一个位置。
   • 如果中间元素大于目标元素，更新右边界为中间位置的前一个位置。
4. 重复：直到找到目标元素或搜索范围为空。

代码实现：

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);

    if (arr[mid] === target) {
      return mid; // 返回目标元素的索引
    }
    if (arr[mid] < target) {
      left = mid + 1; // 目标元素在右半部分
    } else {
      right = mid - 1; // 目标元素在左半部分
    }
  }

  return -1; // 如果没有找到目标元素
}

// 示例
const array = [10, 20, 30, 40, 50];
console.log(binarySearch(array, 30)); // 输出: 2
console.log(binarySearch(array, 60)); // 输出: -1

3. 跳表查找（Skip List）

跳表查找 是一种概率型数据结构，它允许在对数时间内进行查找、插入和删除操作。它通过构建多层索引来加快查找速度。

步骤：

1. 构建跳表：建立一个多层结构，其中每层都是一个有序链表。每个节点在较高层中以某种概率出现，以减少查找路径。
2. 查找元素：
   • 从最上层的链表开始，沿着链表向右移动，直到找到合适的层级。
   • 在找到的链表中向下查找，直到找到目标元素或到达底层链表。

代码实现（简化版，实际应用中较复杂）：

// 简化版跳表实现
class Node {
  constructor(value, forward = []) {
    this.value = value;
    this.forward = forward; // 节点指向不同层的指针
  }
}

class SkipList {
  constructor(maxLevel) {
    this.maxLevel = maxLevel;
    this.header = new Node(null, Array(maxLevel).fill(null));
  }

  // 插入元素
  insert(value) {
    const update = Array(this.maxLevel).fill(null);
    let current = this.header;

    for (let i = this.maxLevel - 1; i >= 0; i--) {
      while (current.forward[i] && current.forward[i].value < value) {
        current = current.forward[i];
      }
      update[i] = current;
    }

    current = current.forward[0];

    if (!current || current.value !== value) {
      const newLevel = this.randomLevel();
      const newNode = new Node(value, Array(newLevel).fill(null));

      for (let i = 0; i < newLevel; i++) {
        newNode.forward[i] = update[i].forward[i];
        update[i].forward[i] = newNode;
      }
    }
  }

  // 查找元素
  search(value) {
    let current = this.header;
    for (let i = this.maxLevel - 1; i >= 0; i--) {
      while (current.forward[i] && current.forward[i].value < value) {
        current = current.forward[i];
      }
    }
    current = current.forward[0];
    return current && current.value === value;
  }

  randomLevel() {
    let level = 1;
    while (Math.random() < 0.5 && level < this.maxLevel) {
      level++;
    }
    return level;
  }
}

// 示例
const skipList = new SkipList(3);
skipList.insert(10);
skipList.insert(20);
skipList.insert(30);
console.log(skipList.search(20)); // 输出: true
console.log(skipList.search(25)); // 输出: false

4. 哈希表查找（Hash Table Search）

哈希表 是一种通过哈希函数将键映射到存储位置的数据结构。它支持在平均情况下以常数时间复杂度完成查找、插入和删除操作。

步骤：

1. 计算哈希值：使用哈希函数将键映射到表中的一个索引位置。
2. 处理冲突：若多个键映射到同一位置，则使用链表或开放地址法处理冲突。
3. 查找：根据哈希值找到相应的位置，检查是否包含目标元素。

代码实现：

class HashTable {
  constructor(size) {
    this.size = size;
    this.table = Array(size).fill(null).map(() => []);
  }

  hash(key) {
    let hash = 0;
    for (let i = 0; i < key.length; i++) {
      hash = (hash + key.charCodeAt(i)) % this.size;
    }
    return hash;
  }

  insert(key, value) {
    const index = this.hash(key);
    const bucket = this.table[index];
    const existingIndex = bucket.findIndex(item => item[0] === key);
    if (existingIndex !== -1) {
      bucket[existingIndex][1] = value; // 更新值
    } else {
      bucket.push([key, value]); // 添加新键值对
    }
  }

  search(key) {
    const index = this.hash(key);
    const bucket = this.table[index];
    const item = bucket.find(item => item[0] === key);
    return item ? item[1] : null; // 返回值或 null
  }
}

// 示例
const hashTable = new HashTable(10);
hashTable.insert('name', 'Alice');
hashTable.insert('age', 30);
console.log(hashTable.search('name')); // 输出: Alice
console.log(hashTable.search('age'));  // 输出: 30
console.log(hashTable.search('address')); // 输出: null

总结

• 线性查找：简单直观，但效率较低，适用于未排序的集合。
• 二分查找：效率高，适用于已排序的数组。
• 跳表查找：适用于动态集合，能够支持快速查找、插入和删除。
• 哈希表查找：支持常数时间复杂度的查找，适用于大规模数据和快速查找需求。

了解这些查找算法及其实现方式可以帮助你在不同场景下选择最适合的查找方法，提升应用的性能和效率。