js 中常用的五种排序算法？

js 中常用的五种排序算法？

冒泡排序

执行过程

• 比较所有相邻元素,如果第一个比第二个大，则交换它们
• 一轮下来保证可以找到一个数是最大的
• 执行 n-1 轮，就可以完成排序

function bubbleSort(arr) {
  const len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}
const numArr = [48, 3, 9, 7, 19, 2, 32, 24, 53, 25, 65, 34];
bubbleSort(numArr);
console.log(numArr); //[2, 3, 7, 9, 19, 24, 25, 32, 34, 48, 53, 65]

选择排序

执行过程

• 找到数组中的最小值，选中它并将其放置在第一位
• 接着找到第二个最小值，选中它并将其放置到第二位
• 执行 n-1 轮，就可以完成排序

function selectionSort(arr) {
  const len = arr.length;
  for (let i = 0; i < len - 1; ++i) {
    // 假设最小的值是当前的下标
    let indexMin = i;
    //遍历剩余长度找到最小下标
    for (let j = i; j < len; ++j) {
      if (arr[j] < arr[indexMin]) {
        indexMin = j;
      }
    }
    if (indexMin !== i) {
      //交换当前下标i与最小下标的值，重复arr.length次
      const temp = arr[i];
      arr[i] = arr[indexMin];
      arr[indexMin] = temp;
    }
  }
}

const numArr = [48, 3, 9, 7, 19, 2, 32, 24, 53, 25, 65, 34];
selectionSort(numArr);
console.log(numArr); //[2, 3, 7, 9, 19, 24, 25, 32, 34, 48, 53, 65]

插入排序

执行过程

• 从第二个数开始往前比
• 比它大就往后排
• 以此类推进行到最后一个数

function insertionSort(arr) {
  const len = arr.length;
  //从第二个数开始往前比
  for (let i = 1; i < len; ++i) {
    //先把值保存起来
    const temp = arr[i];
    let j = i;
    while (j > 0) {
      if (arr[j - 1] > temp) {
        arr[j] = arr[j - 1];
      } else {
        //因为已经是排序过的了，如果比上一位大，那就没必要再跟上上位比较了
        break;
      }
      j -= 1;
    }
    //这里的j有可能是第0位，也有可能是到了一半停止了
    arr[j] = temp;
  }
}

const numArr = [48, 3, 9, 7, 19, 2, 32, 24, 53, 25, 65, 34];
insertionSort(numArr);
console.log(numArr); //[2, 3, 7, 9, 19, 24, 25, 32, 34, 48, 53, 65]

归并排序

执行过程

• 分: 把数组劈成两半，再递归地对数组进行“分”操作，直到分成一个个单独的数
• 合：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个完整数组

function mergeSort(arr) {
  const rec = (arr) => {
    //如果数组长度为1，说明切完了，可以直接返回
    if (arr.length === 1) {
      return arr;
    }
    //切分数组，把每一项都单独切出来
    const mid = Math.floor(arr.length / 2);
    const left = arr.slice(0, mid);
    const right = arr.slice(mid, arr.length);
    //有序的左边数组
    const orderLeft = rec(left);
    //有序的右边数组
    const orderRight = rec(right);
    //定义一个数组来存放顺序数组
    const res = [];
    // 把左右两个有序的合并为一个有序的返回
    while (orderLeft.length || orderRight.length) {
      if (orderLeft.length && orderRight.length) {
        res.push(
          orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift()
        );
      } else if (orderLeft.length) {
        res.push(orderLeft.shift());
      } else if (orderRight.length) {
        res.push(orderRight.shift());
      }
    }
    return res;
  };
  const res = rec(arr);
  //拷贝到数组本身
  res.forEach((n, i) => {
    arr[i] = n;
  });
}

const numArr = [48, 3, 9, 7, 19, 2, 32, 24, 53, 25, 65, 34];
mergeSort(numArr);
console.log(numArr); //[2, 3, 7, 9, 19, 24, 25, 32, 34, 48, 53, 65]

快速排序

执行过程

• 分区: 从数组中任意选择一个基准，所有比基准小的元素放到基准前面，比基准大的元素放到基准的后面。
• 递归：递归地对基准前后的子数组进行分区

function quickSort(arr) {
  const rec = (arr) => {
    // 预防数组是空的或者只有一个元素, 当所有元素都大于等于基准值就会产生空的数组
    if (arr.length === 1 || arr.length === 0) {
      return arr;
    }
    const left = [];
    const right = [];
    //以第一个元素作为基准值
    const mid = arr[0];
    //小于基准值的放左边，大于基准值的放右边
    for (let i = 1; i < arr.length; ++i) {
      if (arr[i] < mid) {
        left.push(arr[i]);
      } else {
        right.push(arr[i]);
      }
    }
    //递归调用，最后放回数组
    return [...rec(left), mid, ...rec(right)];
  };
  const res = rec(arr);
  res.forEach((n, i) => {
    arr[i] = n;
  });
}

const numArr = [48, 3, 9, 7, 19, 2, 32, 24, 53, 25, 65, 34];
quickSort(numArr);
console.log(numArr); //[2, 3, 7, 9, 19, 24, 25, 32, 34, 48, 53, 65]

改自原文链接：https://blog.csdn.net/weixin_46224014/article/details/121231814