TypeScript实现八大排序与搜索算法，解析经典排序和搜索背后的奥秘

前端

2023-10-31 09:25:22

在数据处理的世界里，排序和搜索是永恒的话题。排序是将数据按照一定顺序排列，而搜索则是从数据中找到符合特定条件的元素。

在计算机科学领域，有许多不同的排序和搜索算法，每种算法都有其独特的优缺点。为了帮助开发者们更好地理解和应用这些算法，本文将使用TypeScript来实现八大经典排序算法和三种常用搜索算法。

TypeScript实现八大排序算法

TypeScript是一种功能强大的JavaScript子集，它增加了类型系统和面向对象编程特性，非常适合构建复杂的前端和后端应用程序。

在TypeScript中，我们可以使用各种内置的数据结构和算法来实现排序和搜索。以下是如何使用TypeScript实现八大经典排序算法的示例代码：

冒泡排序

冒泡排序是一种简单的排序算法，它通过反复比较相邻元素，将较大的元素移到后面，直到整个数组有序。

const bubbleSort = (arr: number[]): number[] => {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }

  return arr;
};

选择排序

选择排序是一种不稳定的排序算法，它通过在未排序的数组中找到最小元素，然后将其与数组的第一个元素交换，依此类推，直到整个数组有序。

const selectionSort = (arr: number[]): number[] => {
  for (let i = 0; i < arr.length - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }

    const temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }

  return arr;
};

插入排序

插入排序是一种稳定的排序算法，它通过将每个元素依次插入到已排序的数组中来实现排序。

const insertionSort = (arr: number[]): number[] => {
  for (let i = 1; i < arr.length; i++) {
    const currentElement = arr[i];
    let j = i - 1;
    while (j >= 0 && currentElement < arr[j]) {
      arr[j + 1] = arr[j];
      j--;
    }

    arr[j + 1] = currentElement;
  }

  return arr;
};

希尔排序

希尔排序是一种不稳定的排序算法，它通过将数组分成若干个子数组，然后对每个子数组进行插入排序来实现排序。

const shellSort = (arr: number[]): number[] => {
  const gaps = [5, 3, 1];

  for (const gap of gaps) {
    for (let i = gap; i < arr.length; i++) {
      const currentElement = arr[i];
      let j = i - gap;
      while (j >= 0 && currentElement < arr[j]) {
        arr[j + gap] = arr[j];
        j -= gap;
      }

      arr[j + gap] = currentElement;
    }
  }

  return arr;
};

归并排序

归并排序是一种稳定的排序算法，它通过将数组分成两半，然后对每一半进行递归排序，最后将两个有序的子数组合并成一个有序的数组。

const mergeSort = (arr: number[]): number[] => {
  if (arr.length <= 1) {
    return arr;
  }

  const midIndex = Math.floor(arr.length / 2);
  const leftHalf = mergeSort(arr.slice(0, midIndex));
  const rightHalf = mergeSort(arr.slice(midIndex));

  return merge(leftHalf, rightHalf);
};

const merge = (left: number[], right: number[]): number[] => {
  const mergedArray = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] <= right[rightIndex]) {
      mergedArray.push(left[leftIndex]);
      leftIndex++;
    } else {
      mergedArray.push(right[rightIndex]);
      rightIndex++;
    }
  }

  while (leftIndex < left.length) {
    mergedArray.push(left[leftIndex]);
    leftIndex++;
  }

  while (rightIndex < right.length) {
    mergedArray.push(right[rightIndex]);
    rightIndex++;
  }

  return mergedArray;
};

快速排序

快速排序是一种不稳定的排序算法，它通过选择一个枢轴元素，然后将数组分成两部分：一部分包含小于枢轴元素的元素，另一部分包含大于枢轴元素的元素。然后对每一部分进行递归排序，直到整个数组有序。

const quickSort = (arr: number[]): number[] => {
  if (arr.length <= 1) {
    return arr;
  }

  const pivotIndex = Math.floor(arr.length / 2);
  const pivot = arr[pivotIndex];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length; i++) {
    if (i === pivotIndex) {
      continue;
    }

    if (arr[i] <= pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
};

堆排序

堆排序是一种不稳定的排序算法，它通过将数组构建成一个二叉堆，然后将堆顶元素与最后一个元素交换，然后重新调整堆，直到整个数组有序。

const heapSort = (arr: number[]): number[] => {
  const heapSize = arr.length;

  for (let i = Math.floor(heapSize / 2 - 1); i >= 0; i--) {
    heapify(arr, heapSize, i);
  }

  for (let i = heapSize - 1; i >= 0; i--) {
    const temp = arr[0];
    arr[0] = arr[i];
    arr[i] = temp;

    heapify(arr, i, 0);
  }

  return arr;
};

const heapify = (arr: number[], heapSize: number, index: number) => {
  const leftIndex = 2 * index + 1;
  const rightIndex = 2 * index + 2;

  let largestIndex = index;

  if (leftIndex < heapSize && arr[leftIndex] > arr[largestIndex]) {
    largestIndex = leftIndex;
  }

  if (rightIndex < heapSize && arr[rightIndex] > arr[largestIndex]) {
    largestIndex = rightIndex;
  }

  if (largestIndex !== index) {
    const temp = arr[index];
    arr[index] = arr[largestIndex];
    arr[largestIndex] = temp;

    heapify(arr, heapSize, largestIndex);
  }
};