JavaScript 堆数据结构详解：高效管理您的数据

前端

2024-01-19 17:52:18

什么是堆数据结构？

堆是一种特殊的二叉树，其中每个节点的值都大于或小于其子节点的值。这种特性使堆非常适合用于优先级队列和堆排序等应用程序。

堆的类型

堆有两种主要类型：

最小堆： 最小堆中，每个节点的值都小于或等于其子节点的值。这意味着堆的根节点总是包含集合中的最小值。
最大堆： 最大堆中，每个节点的值都大于或等于其子节点的值。这意味着堆的根节点总是包含集合中的最大值。

堆的操作

堆支持以下基本操作：

插入： 向堆中插入一个元素。
删除： 从堆中删除一个元素。
查找： 在堆中查找一个元素。
排序： 使用堆对一组元素进行排序。

堆的应用

堆在计算机科学中有很多应用，包括：

优先级队列： 堆可用于实现优先级队列，其中优先级最高的元素始终位于堆的顶部。这使得堆非常适合用于调度任务或处理事件。
堆排序： 堆排序是一种使用堆对数组进行排序的算法。堆排序的时间复杂度为 O(n log n)，这使其成为一种非常有效的排序算法。
图论： 堆可用于解决图论中的许多问题，例如寻找最短路径或生成最小生成树。

结论

堆是一种非常强大的数据结构，可以在许多不同的应用程序中使用。如果您正在寻找一种可以高效管理数据的结构，那么堆是一个很好的选择。

代码示例

以下是一个使用 JavaScript 实现的堆数据结构的示例：

class Heap {
  constructor(type) {
    this.type = type;
    this.heap = [];
  }

  insert(value) {
    this.heap.push(value);
    this.heapifyUp();
  }

  delete() {
    if (this.heap.length === 0) {
      return null;
    }

    const root = this.heap[0];
    this.heap[0] = this.heap.pop();
    this.heapifyDown();

    return root;
  }

  find(value) {
    for (let i = 0; i < this.heap.length; i++) {
      if (this.heap[i] === value) {
        return i;
      }
    }

    return -1;
  }

  sort() {
    const sortedArray = [];

    while (this.heap.length > 0) {
      sortedArray.push(this.delete());
    }

    return sortedArray;
  }

  heapifyUp() {
    let index = this.heap.length - 1;

    while (index > 0) {
      const parentIndex = Math.floor((index - 1) / 2);

      if (this.type === 'min' && this.heap[index] < this.heap[parentIndex]) {
        this.swap(index, parentIndex);
        index = parentIndex;
      } else if (this.type === 'max' && this.heap[index] > this.heap[parentIndex]) {
        this.swap(index, parentIndex);
        index = parentIndex;
      } else {
        break;
      }
    }
  }

  heapifyDown() {
    let index = 0;

    while (index < this.heap.length) {
      const leftChildIndex = 2 * index + 1;
      const rightChildIndex = 2 * index + 2;

      let largestChildIndex = index;

      if (this.type === 'min') {
        if (leftChildIndex < this.heap.length && this.heap[leftChildIndex] < this.heap[index]) {
          largestChildIndex = leftChildIndex;
        }

        if (rightChildIndex < this.heap.length && this.heap[rightChildIndex] < this.heap[largestChildIndex]) {
          largestChildIndex = rightChildIndex;
        }
      } else if (this.type === 'max') {
        if (leftChildIndex < this.heap.length && this.heap[leftChildIndex] > this.heap[index]) {
          largestChildIndex = leftChildIndex;
        }

        if (rightChildIndex < this.heap.length && this.heap[rightChildIndex] > this.heap[largestChildIndex]) {
          largestChildIndex = rightChildIndex;
        }
      }

      if (largestChildIndex !== index) {
        this.swap(index, largestChildIndex);
        index = largestChildIndex;
      } else {
        break;
      }
    }
  }

  swap(index1, index2) {
    const temp = this.heap[index1];
    this.heap[index1] = this.heap[index2];
    this.heap[index2] = temp;
  }
}

const minHeap = new Heap('min');
minHeap.insert(10);
minHeap.insert(5);
minHeap.insert(15);
minHeap.insert(3);
minHeap.insert(7);

console.log(minHeap.sort()); // [3, 5, 7, 10, 15]

const maxHeap = new Heap('max');
maxHeap.insert(10);
maxHeap.insert(5);
maxHeap.insert(15);
maxHeap.insert(3);
maxHeap.insert(7);

console.log(maxHeap.sort()); // [15, 10, 7, 5, 3]