js - 常用的数组排序算法

本篇介绍四种常用的排序算法：分别是

1. 冒泡排序
2. 选择排序
3. 快速排序
4. 插入排序

其中速度对比：快速 > 插入 > 选择 > 冒泡

1，冒泡排序

1,比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2,对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3,针对所有的元素重复以上的步骤，除了最后一个；
4,重复步骤1~3，直到排序完成

冒泡排序
let arr = [55, 44, 33, 66, 77, 11, 22, 88, 99, 0];
function bubbleSort(arr) {
  let len = arr.length;
  // 外层控制轮数
  for (let i = 0; i <= arr.length - 1; i++) {
    // 内层控制次数
    for (let j = 0; j < arr.length - 1 - i; j++) {
      // 相邻元素两两对比 如果前面的大于后面的  就把小的交换位置放到前面来
      if (arr[j] > arr[j + 1]) {
        var temp = arr[j + 1]; // 元素交换
        arr[j + 1] = arr[j];
        arr[j] = temp;
      }
    }
  }
  //   排序完成后 返回数组
  return arr;
}

2，选择排序

1，第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置；
2，然后再从剩余的未排序元素中寻找到最小（大）元素；
3，然后放到已排序的序列的开头。以此类推，直到全部待排序的数据元素的个数为零,；

选择排序
let arr2 = [55, 44, 33, 66, 77, 11, 22, 88, 99, 0];
function selectionSort(arr) {
  let len = arr.length;
  let minIndex, temp;
  for (let i = 0; i <= len - 1; i++) {
    minIndex = i; // 每一个元素都和剩下的未排序的元素比较
    for (let j = i + 1; j < len; j++) {
      // 寻找最小的数
      if (arr[j] < arr[minIndex]) {
        minIndex = j; // 将最小数的索引保存
      }
    }
    temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

3，快速排序

1，定义一个函数，传入参数，判断这个参数的长度，如果长度是1，直接ruturn出去，如果是进入下一步；
2，将这个数组从中间截取，取出这个数组的中位数，定义两个新的数组arrleft,arrright,然后让原数组中剩余的数与这个中位数比较，比中位数小的放到arrleft数组，比中位数大的放到arrright
3，然后再对这两个数组进行递归调用；
4，最后将arrleft,中位数，arrright拼接。return出去。

快速排序
let arr4 = [55, 44, 33, 66, 77, 11, 22, 88, 99, 0];
// 里面用到了递归调用
function quickSort(ary) {
  // 1，注意：递归调用一定要有结束的条件 否则会造成无限循环
  // 当数组为空 结束调用
  if (ary.length <= 1) {
    return ary;
  }
  //2.如果长度不为1，那么就取数组的中间值
  let contentIndex = Math.floor(ary.length / 2); //向下取整
  let contentValue = ary.splice(contentIndex, 1)[0]; // splice会返回切割的这一项 是一个数组 所以要取第0项
  console.log("中位数：",ary.splice(contentIndex, 1));
  //3.先定义左右两个数组，然后让数组中剩余的数与中间数进行比较，比中间数小的放到左边的数组，比中间数大的放到右边的数组。
  console.log("ary:",ary);
  let leftArr = [];
  let rightArr = [];
  for (let i = 0; i < ary.length; i++) {
    let item = ary[i];
    item > contentValue ? rightArr.push(item) : leftArr.push(item);
  }
  //4.使用递归的方式让左右两边的数组持续这样处理，直至左右两边的数组都排好序，最后三者进行拼接
  return quickSort(leftArr).concat(contentValue, quickSort(rightArr));
}

4，插入排序

插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，
对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序
let arr3 = [55, 44, 33, 66, 77, 11, 22, 88, 99, 0];
function insertionSort(arr) {
  var len = arr.length;
  var preIndex, current;
  for (var i = 1; i < len; i++) {
    preIndex = i - 1;
    current = arr[i];
    while (preIndex >= 0 && arr[preIndex] > current) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  return arr;
}