剖析前端排序算法利器：基数、堆和桶排序全解析

前端

2023-08-07 11:08:19

高级排序算法：基数排序、堆排序和桶排序

导言

在前端开发中，排序算法是必不可少的工具，它们帮助我们高效地整理数据，提高程序性能。本文深入探讨三种高级排序算法：基数排序、堆排序和桶排序，并提供详细的实现和复杂度分析。

基数排序：按位值排序

基数排序是一种非比较性排序算法，它按元素的各个位值进行排序。它将数据分为多个桶，每个桶存放具有相同位值的元素。然后，将每个桶中的元素按顺序取出并重新排列，直至所有位值排序完成。基数排序特别适合处理大量整数数据。

堆排序：基于堆数据结构

堆排序利用堆数据结构进行排序。堆是一种完全二叉树，其中每个父节点的值大于或等于其子节点的值。算法将数据构建成一个堆，然后从堆顶依次取出元素并插入到已排序序列中。堆排序是一种高效的排序算法，特别是对于小数据量。

桶排序：数据范围划分

桶排序是一种非比较性排序算法，它将数据划分为多个桶，每个桶包含一定范围的元素。然后，对每个桶中的数据进行排序，并将桶中的数据按顺序合并。桶排序特别适合处理数据范围较小的数据。

代码示例：TypeScript 和 C

基数排序

function radixSort(nums: number[]): number[] {
  let maxNum = Math.max(...nums);
  let exp = 1;
  while (maxNum / exp > 0) {
    countingSort(nums, exp);
    exp *= 10;
  }
  return nums;
}

function countingSort(nums: number[], exp: number): void {
  let n = nums.length;
  let output: number[] = new Array(n);
  let count: number[] = new Array(10).fill(0);
  for (let i = 0; i < n; i++) {
    let index = Math.floor(nums[i] / exp) % 10;
    count[index]++;
  }
  for (let i = 1; i < 10; i++) {
    count[i] += count[i - 1];
  }
  for (let i = n - 1; i >= 0; i--) {
    let index = Math.floor(nums[i] / exp) % 10;
    output[count[index] - 1] = nums[i];
    count[index]--;
  }
  for (let i = 0; i < n; i++) {
    nums[i] = output[i];
  }
}

堆排序

function heapSort(nums: number[]): number[] {
  buildMaxHeap(nums);
  for (let i = nums.length - 1; i > 0; i--) {
    [nums[0], nums[i]] = [nums[i], nums[0]];
    maxHeapify(nums, 0, i);
  }
  return nums;
}

function buildMaxHeap(nums: number[]): void {
  for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
    maxHeapify(nums, i, nums.length);
  }
}

function maxHeapify(nums: number[], i: number, n: number): void {
  let largest = i;
  let left = 2 * i + 1;
  let right = 2 * i + 2;
  if (left < n && nums[left] > nums[largest]) {
    largest = left;
  }
  if (right < n && nums[right] > nums[largest]) {
    largest = right;
  }
  if (largest !== i) {
    [nums[i], nums[largest]] = [nums[largest], nums[i]];
    maxHeapify(nums, largest, n);
  }
}

桶排序

function bucketSort(nums: number[]): number[] {
  let maxNum = Math.max(...nums);
  let minNum = Math.min(...nums);
  let bucketSize = Math.floor((maxNum - minNum) / nums.length) + 1;
  let buckets: number[][] = new Array(bucketSize);
  for (let i = 0; i < bucketSize; i++) {
    buckets[i] = [];
  }
  for (let num of nums) {
    let bucketIndex = Math.floor((num - minNum) / bucketSize);
    buckets[bucketIndex].push(num);
  }
  for (let bucket of buckets) {
    bucket.sort((a, b) => a - b);
  }
  let sortedNums: number[] = [];
  for (let bucket of buckets) {
    sortedNums = sortedNums.concat(bucket);
  }
  return sortedNums;
}