JavaScript实现冒泡排序法、插入排序法、快速排序法

1.冒泡排序法

1.1 概念

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

1.2 原理示意图

1.3 代码

const arr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 9, 1]

  function bubbleSort(arr) {
    const len = arr.length
    // 外层循环i控制比较的轮数
    for (let i = 0; i < len; i++) {
      // 里层循环控制每一轮比较的次数j，arr[i] 只用跟其余的len - i个元素比较
      for (let j = 1; j < len - i; j++) {
        // 若前一个元素"大于"后一个元素，则两者交换位置
        if (arr[j - 1] > arr[j]) {
          [arr[j - 1], arr[j]] = [arr[j], arr[j - 1]]
        }
      }
    }
    return arr
  }

  console.log(bubbleSort(arr))	// [1, 2,  5,  7,  7, 8, 9, 12, 34, 39, 56]
  

改进的冒泡排序法：

function bubbleSort(arr) {
    let temp = null, flag = 1
    const len = arr.length
    for (let i = 0; i <= len - 1 && flag === 1; i++) {
      flag = 0
      for (let j = 0; j < len - i; j++) {
        if (arr[j] > arr[j + 1]) {
          temp = arr[j + 1]
          arr[j + 1] = arr[j]
          arr[j] = temp
          flag = 1// 发生数据交换flag置为1
        }
      }
    }
    return arr
  }

2.插入排序法

2.1 概念

一般也被称为直接插入排序（Insert Sort）。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。

2.2 原理示意图

插入排序的工作方式像许多人排序一手扑克牌。开始时，我们的左手为空并且桌子上的牌面向下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。拿在左手上的牌总是排序好的，原来这些牌是桌子上牌堆中顶部的牌 。

2.3 代码

function quickSort(arr) {
  // 4.结束递归（当ary小于等于一项，则不用处理）
  if (arr.length <= 1) {
    return arr
  }
  // 1. 找到数组的中间项，在原有的数组中把它移除
  const middleIndex = Math.floor(arr.length / 2)
  const middle = arr.splice(middleIndex, 1)[0]
  // 2. 准备左右两个数组，循环剩下数组中的每一项，比当前项小的放到左边数组中，反之放到右边数组中
  const leftArr = [], rightArr = []
  for (let i = 0; i < arr.length; i++) {
    const current = arr[i]
    current < middle ? leftArr.push(current) : rightArr.push(current)

  }
  // 3. 递归方式让左右两边的数组持续这样处理，一直到左右两边都排好序为止。
  //（最后让左边+中间+右边拼接成最后的结果）
  return quickSort(leftArr).concat(middle, quickSort(rightArr))
}

另一种解法：

  const arr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 9, 1]

  function insertSort(arr) {
    const handle = [arr[0]], len = arr.length
    for (let i = 1; i <= len - 1; i++) {
      const current = arr[i]
      for (var j = handle.length - 1; j >= 0; j--) {
        if (current > handle[j]) {
          handle.splice(j + 1, 0, current)
          break
        }
        if (j === 0) {
          handle.unshift(current)
        }
      }
    }
    return handle
  }

  console.log(insertSort(arr))	// [1, 2,  5,  7,  7, 8, 9, 12, 34, 39, 56]
  

优化的插入排序法：

	//将arr[]按升序排列，插入排序法
  function insertSort(arr) {
    for (let i = 1; i < arr.length; i++) {
      //将arr[i]插入到arr[i-1]，arr[i-2]，arr[i-3]……之中
      for (let j = i; j > 0; j--) {
        if (arr[j] < arr[j - 1]) {
          [arr[j - 1], arr[j]] = [arr[j], arr[j - 1]]
        }
      }
    }
    return arr
  }

3.快速排序法

3.1 概念

快速排序（Quick Sort）是对冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

3.2 原理示意图##### 3.3 代码

function quickSort(arr) {
  // 4.结束递归（当ary小于等于一项，则不用处理）
  if (arr.length <= 1) {
    return arr
  }
  // 1. 找到数组的中间项，在原有的数组中把它移除
  const middleIndex = Math.floor(arr.length / 2)
  const middle = arr.splice(middleIndex, 1)[0]
  // 2. 准备左右两个数组，循环剩下数组中的每一项，比当前项小的放到左边数组中，反之放到右边数组中
  const leftArr = [], rightArr = []
  for (let i = 0; i < arr.length; i++) {
    const current = arr[i]
    current < middle ? leftArr.push(current) : rightArr.push(current)

  }
  // 3. 递归方式让左右两边的数组持续这样处理，一直到左右两边都排好序为止。
  //（最后让左边+中间+右边拼接成最后的结果）
  return quickSort(leftArr).concat(middle, quickSort(rightArr))
}

另一种写法：

  const arr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 9, 1]

  function quickSort(outter) {
    function sort(arr, left = 0, right = arr.length - 1) {
      if (left >= right) {    //如果左边的索引大于等于右边的索引说明整理完毕
        return
      }
      let i = left, j = right
      const baseVal = arr[j]  // 取无序数组最后一个数为基准值
      while (i < j) {         //把所有比基准值小的数放在左边大的数放在右边
        while (i < j && arr[i] <= baseVal) { //找到一个比基准值大的数交换
          i++
        }
        arr[j] = arr[i] // 将较大的值放在右边如果没有比基准值大的数就是将自己赋值给自己（i 等于 j）
        while (j > i && arr[j] >= baseVal) {  //找到一个比基准值小的数交换
          j--
        }
        arr[i] = arr[j] // 将较小的值放在左边如果没有找到比基准值小的数就是将自己赋值给自己（i 等于 j）

      }
      arr[j] = baseVal        // 将基准值放至中央位置完成一次循环（这时候 j 等于 i ）
      sort(arr, left, j - 1)  // 将左边的无序数组重复上面的操作
      sort(arr, j + 1, right) // 将右边的无序数组重复上面的操作
    }

    const newArr = outter.concat()// 为了保证这个函数是纯函数拷贝一次数组
    sort(newArr)
    return newArr
  }

  console.log(bubbleSort(arr))	// [1, 2,  5,  7,  7, 8, 9, 12, 34, 39, 56]
  

4.十大排序空间复杂度和时间复杂度：