前端实现排序算法：快排、堆排、优先级队列

2024-01-27 01:28:30

导言

在现代网络应用中，排序算法对于有效管理和处理大量数据至关重要。JavaScript 作为一种流行的前端编程语言，提供了丰富的工具和技术来实现高效的排序算法。在本文中，我们将重点介绍三种关键的排序算法：快排、堆排和优先级队列，并指导您在前端环境中使用 JavaScript 实现这些算法。

快排

快排是一种分治算法，以其平均时间复杂度 O(N * logN) 而闻名。它通过递归地将数组划分为较小的部分，并使用一个枢纽元素将这些部分排序，来实现快速排序。

JavaScript 实现

const quickSort = (arr) => {
  if (arr.length <= 1) return arr;
  const pivot = arr[0];
  const left = [];
  const right = [];
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
};

堆排

堆排是一种基于二叉堆的数据结构的排序算法。它以 O(N * logN) 的时间复杂度将无序数组转换为有序数组。

JavaScript 实现

const heapSort = (arr) => {
  const heap = [];
  for (let i = 0; i < arr.length; i++) {
    heap.push(arr[i]);
    heapifyUp(heap, i);
  }
  for (let i = arr.length - 1; i >= 0; i--) {
    swap(heap, 0, i);
    heapifyDown(heap, 0, i);
  }
  return heap;

  // 辅助函数，用于向上堆化
  const heapifyUp = (heap, index) => {
    while (index > 0) {
      const parentIndex = Math.floor((index - 1) / 2);
      if (heap[index] > heap[parentIndex]) {
        swap(heap, index, parentIndex);
        index = parentIndex;
      } else {
        break;
      }
    }
  };

  // 辅助函数，用于向下堆化
  const heapifyDown = (heap, index, end) => {
    while (2 * index + 1 < end) {
      const leftChildIndex = 2 * index + 1;
      const rightChildIndex = 2 * index + 2;
      let swapIndex = index;
      if (heap[leftChildIndex] > heap[swapIndex]) {
        swapIndex = leftChildIndex;
      }
      if (rightChildIndex < end && heap[rightChildIndex] > heap[swapIndex]) {
        swapIndex = rightChildIndex;
      }
      if (swapIndex === index) {
        break;
      } else {
        swap(heap, index, swapIndex);
        index = swapIndex;
      }
    }
  };

  // 辅助函数，用于交换两个元素
  const swap = (arr, i, j) => {
    const temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  };
};

优先级队列

优先级队列是一种抽象数据类型，它允许以优先级顺序访问和删除元素。在 JavaScript 中，可以使用最小堆来实现优先级队列。

JavaScript 实现

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

  push(value, priority) {
    this.heap.push({ value, priority });
    heapifyUp(this.heap, this.heap.length - 1);
  }

  pop() {
    if (this.heap.length === 0) return null;
    const root = this.heap[0];
    this.heap[0] = this.heap[this.heap.length - 1];
    this.heap.pop();
    heapifyDown(this.heap, 0);
    return root.value;
  }

  peek() {
    return this.heap[0] ? this.heap[0].value : null;
  }

  heapifyUp(index) {
    while (index > 0) {
      const parentIndex = Math.floor((index - 1) / 2);
      if (this.heap[index].priority > this.heap[parentIndex].priority) {
        swap(this.heap, index, parentIndex);
        index = parentIndex;
      } else {
        break;
      }
    }
  }

  heapifyDown(index, end) {
    while (2 * index + 1 < end) {
      const leftChildIndex = 2 * index + 1;
      const rightChildIndex = 2 * index + 2;
      let swapIndex = index;
      if (this.heap[leftChildIndex].priority > this.heap[swapIndex].priority) {
        swapIndex = leftChildIndex;
      }
      if (rightChildIndex < end && this.heap[rightChildIndex].priority > this.heap[swapIndex].priority) {
        swapIndex = rightChildIndex;
      }
      if (swapIndex === index) {
        break;
      } else {
        swap(this.heap, index, swapIndex);
        index = swapIndex;
      }
    }
  }

  swap(i, j) {
    const temp = this.heap[i];
    this.heap[i] = this.heap[j];
    this.heap[j] = temp;
  }
}