JavaScript实现快速排序、归并排序、堆排序

快速排序

通过选择一个基准元素，将数组划分为左右两个子数组，左边的元素小于等于基准，右边的元素大于基准，然后递归地对左右两个子数组进行快速排序，直到排序完成。

• 判断数组长度是否小于等于1
• 通过选择一个基准元素，将数组划分为左右两个子数组，左边的元素小于等于基准，右边的元素大于基准。
• 循环遍历数组，将比基小放在left数组中，将比基大放在right数组中。
• 然后递归地对左右两个子数组进行快速排序，直到排序完成。
• 平均时间复杂度为O(nlogn)

function quickSort(arr) {
    //如果数组长度小于等于1，则无需排序，直接返回。
    //注意这里要判断，否则不能使用 Math.floor()
    if (arr.length <= 1) {
        return arr;
    }

    //选择基准元素，Math.floor()向下取整
    const pivotIndex = Math.floor(arr.length / 2);
    const pivot = arr[pivotIndex];

    //初始化左右两个子数组
    const left = [];
    const right = [];

    //遍历数组，将比基小放在left数组中，将比基大放在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 arr = [2, 4, 1, 5, 3];
console.log(quickSort(arr));

归并排序

将数组不断二分为更小的子数组，然后将子数组逐个合并为有序数组，重复这个过程直到整个数组有序。

• 判断数组长度是否小于等于1
• 将数组分为左右两个子数组
• 递归对子数组进行归并排序
• 合并两个有序子数组
• 平均时间复杂度为O(nlogn)

function mergeSort(arr) {
    // 判断数组长度是否小于等于1，如果是则已经有序，直接返回
    if (arr.length <= 1) {
        return arr;
    }

    // 将数组分为两个子数组
    const middle = Math.floor(arr.length / 2);
    const leftArr = arr.slice(0, middle); // 左半部分
    const rightArr = arr.slice(middle); // 右半部分

    // 递归对子数组进行归并排序
    const sortedLeftArr = mergeSort(leftArr);
    const sortedRightArr = mergeSort(rightArr);

    // 合并两个有序子数组
    return merge(sortedLeftArr, sortedRightArr);
}

// 合并两个有序数组的函数
function merge(leftArr, rightArr) {
    let mergedArr = [];
    let leftIndex = 0;
    let rightIndex = 0;

    // 比较两个子数组的元素，将较小的元素加入到结果数组中
    while (leftIndex < leftArr.length && rightIndex < rightArr.length) {
        if (leftArr[leftIndex] < rightArr[rightIndex]) {
            mergedArr.push(leftArr[leftIndex]);
            leftIndex++;
        } else {
            mergedArr.push(rightArr[rightIndex]);
            rightIndex++;
        }
    }

    // 将剩余元素加入到结果数组中
    return mergedArr.concat(leftArr.slice(leftIndex)).concat(rightArr.slice(rightIndex));
}

const arr = [2, 1, 5, 3, 4];
console.log(mergeSort(arr));

堆排序

通过构建一个二叉堆，将堆顶元素与堆尾元素交换，并重新调整堆使其满足堆的性质，重复这个过程直到排序完成。平均事件复杂度为O(nlogn)

堆和数组的区别：

1. 堆是一种基于树的数据结构，而数组是一种线性结构
2. 数组通过下标访问元素，时间复杂度为 O(1)，但插入和删除元素的效率较低；堆在插入和删除元素时效率较高，但访问元素时的时间复杂度为 O(logn)
3. 数组可以存储任何数据类型的元素，而堆通常只用于存储可比较的元素，并且堆通常用于实现优先队列和堆排序算法。

function heapify(arr, n, i) {
  let largest = i; // 初始化当前节点为最大值
  let l = 2 * i + 1; // 左子节点的索引
  let r = 2 * i + 2; // 右子节点的索引

  // 如果左子节点存在并且大于当前节点，更新最大值索引
  if (l < n && arr[l] > arr[largest]) {
    largest = l;
  }

  // 如果右子节点存在并且大于当前节点，更新最大值索引
  if (r < n && arr[r] > arr[largest]) {
    largest = r;
  }

  // 如果最大值索引不等于当前节点索引，交换节点值，并继续堆化
  if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]];
    heapify(arr, n, largest);
  }
}

// 堆排序函数
function heapSort(arr) {
  const n = arr.length;

  // 构建最大堆
  for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
    heapify(arr, n, i);
  }

  // 堆排序
  for (let i = n - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]]; // 将当前根节点移动到末尾

    heapify(arr, i, 0); // 对新的堆进行堆化
  }

  return arr;
}

// 示例用法
const arr = [12, 11, 13, 5, 6, 7];
console.log("原始数组: " + arr);
console.log("排序后数组: " + heapSort(arr));