前端必掌握的Fisher-Yates 洗牌算法等

feellikeatypo

于 2023-11-27 14:51:06 发布

阅读量1.9k

点赞数 53

文章标签：数据结构前端排序算法算法 javascript

本文链接：https://blog.csdn.net/weixin_74085863/article/details/134558244

版权

本文介绍了Fisher-Yates洗牌算法、快速排序（Quicksort）的实现及优化、归并排序（MergeSort）的过程，以及二分查找（BinarySearch）的工作原理，展示了这些在IT技术中的重要性和应用。

摘要由CSDN通过智能技术生成

洗牌算法(Fisher-Yates)

Fisher-Yates 洗牌算法，也被称为高纳德洗牌算法，是一种用于将数组元素随机排序的经典算法。这个算法的基本思想是从数组末尾开始，每次随机选择一个位置，然后将该位置的元素与末尾元素进行交换，然后在剩余的元素中继续进行这个过程，直到所有元素都被遍历过。这样就能够实现对数组的随机洗牌，生成一个随机排列的数组。

const shuffleArray = array => {
  for (let i = array.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [array[i], array[j]] = [array[j], array[i]];
  }
  return array;
};

这是最开始使用的洗牌代码但是经过我研究,发现存在这样一个问题，即在每次迭代中，随机交换的范围会逐渐缩小，可能导致最后几个元素的位置不够随机。这个问题可以通过在每次迭代中使用整个数组长度来选择随机位置的方式来解决。这样可以确保每个位置被交换的概率是相同的，从而保证了随机性。

    const shuffleArray = array => {
        for (let i = array.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * array.length);
            [array[i], array[j]] = [array[j], array[i]];
        }
        return array;
    };

快速排序（Quicksort）

快速排序是一种高效的排序算法，它基于分治的思想，通过递归地将数组分成较小的子数组，然后对子数组进行排序，最终将数组排序好。快速排序的平均时间复杂度为 O(n log n)，是排序算法中性能较好的一种。

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

核心代码其实就一句:return quickSort(left).concat(pivot, quickSort(right));

是的.这句就是使用的递归的思想,简单理解就是它将起始数组分为(小于基准)基准(大于基准),再依次将(小于基准)和(大于基准)中再次递归分出小于基准中的基准再去分这个递归后的基准的小于基准和大于基准...最后再将所有的小数组拼接起来,可能情况就是[小数组]基准[小数组]基准[小数组]基准[小数组]基准[小数组]的情况

归并排序（Merge Sort）

归并排序也是一种常见的排序算法，它同样基于分治的思想，通过将数组分成较小的子数组，然后对子数组进行排序并合并，最终将数组排序好。归并排序同样具有 O(n log n) 的时间复杂度，而且它是一种稳定的排序算法。

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }

  const middle = Math.floor(arr.length / 2);
  const left = arr.slice(0, middle);
  const right = arr.slice(middle);

  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

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

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

// 示例
const arr = [5, 3, 8, 6, 2, 7, 1, 4];
const sortedArr = mergeSort(arr);
console.log(sortedArr); // [1, 2, 3, 4, 5, 6, 7, 8]

为了防止之后自己看代码看不懂,我对于我觉得较绕的代码会做分析

当我代入数组 [3, 1, 2, 4] 并调用 mergeSort 函数时，接下来一步一步地来跟踪函数的执行过程。

首先，我调用 mergeSort([3, 1, 2, 4])。
在 mergeSort 函数中，数组长度大于 1，所以我们计算中间索引并将数组分成两部分：
- left：[3, 1]
- right：[2, 4]
然后我递归调用 mergeSort 函数：
- 对于 left，调用 mergeSort([3, 1])。
- 对于 right，调用 mergeSort([2, 4])。
继续递归，对于 left 的递归调用，数组长度大于 1，所以我计算中间索引并将数组分成两部分：
- left：[3]
- right：[1]
对于 right 的递归调用，数组长度等于 1，所以返回数组 [1]。
对于 left 的递归调用，数组长度等于 1，所以返回数组 [3]。
现在我将得到的两个有序数组 [3] 和 [1] 传递给 merge 函数进行合并：
- left：[3]
- right：[1]
在 merge 函数中，我比较 3 和 1，然后将 1 放入结果数组，通过concat得到 [1, 3]。
接着，我对 right 的递归调用进行类似的步骤：
- 对于 left，得到 [2]。
- 对于 right，得到 [4]。
现在我将得到的两个有序数组 [2] 和 [4] 传递给 merge 函数进行合并：
- left：[2]
- right：[4]
在 merge 函数中，我比较 2 和 4，然后将 2 放入结果数组，通过concat得到 [2, 4]。
最后，我将得到的两个有序数组 [1, 3] 和 [2, 4] 传递给 merge 函数进行合并：
- left：[1, 3]
- right：[2, 4]
得到 merge([1, 3], [2, 4]) 后，我将这两个有序数组合并成一个有序数组。下面是合并的过程：

我创建一个空数组 result 来保存合并后的结果。

然后定义两个指针 leftIndex 和 rightIndex，分别指向左数组和右数组的起始位置。

我们比较左数组和右数组的第一个元素，将较小的元素放入 result 数组中，并将对应数组的指针向后移动一位。

在这个例子中，左数组的第一个元素是 1，右数组的第一个元素是 2，所以我们将 1 放入 result 数组中，并将 leftIndex 向后移动一位。

现在，result 数组为 [1]，leftIndex 为 1，rightIndex 为 0。

接下来再次比较左数组和右数组的第一个元素，将较小的元素放入 result 数组中，并将对应数组的指针向后移动一位。

在这个例子中，左数组的第二个元素是 3，右数组的第一个元素仍然是 2，所以我们将 2 放入 result 数组中，并将 rightIndex 向后移动一位。

现在，result 数组为 [1, 2]，leftIndex 为 1，rightIndex 为 1。

我们再次比较左数组和右数组的第一个元素，将较小的元素放入 result 数组中，并将对应数组的指针向后移动一位。

在这个例子中，左数组的第二个元素仍然是 3，右数组的第二个元素是 4，所以我们将 3 放入 result 数组中，并将 leftIndex 向后移动一位。

现在，result 数组为 [1, 2, 3]，leftIndex 为 2，rightIndex 为 1。

当再次进入while时,不满足条件,然后直接将剩余的[4]concat到result中得到最终结果

二分查找（Binary Search）

二分查找是一种高效的搜索算法，它适用于已排序的数组。通过比较数组中间元素和目标值的大小关系，二分查找可以快速地缩小搜索范围，最终找到目标值的位置。二分查找的时间复杂度为 O(log n)。

function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;

    while (left <= right) {
        let mid = Math.floor((left + right) / 2);

        if (arr[mid] === target) {
            return mid; // 找到目标元素，返回索引
        } else if (arr[mid] < target) {
            left = mid + 1; // 目标元素在右半部分
        } else {
            right = mid - 1; // 目标元素在左半部分
        }
    }

    return -1; // 目标元素不存在于数组中
}

//
let arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
let target = 11;
let result = binarySearch(arr, target);
console.log(result); // 输出：5

首先初始化左右边界，然后在一个 while 循环中不断缩小搜索范围，直到找到目标元素或者确定目标元素不存在为止。