Day5.排序算法

快速排序

1. 快排数组 = 选择某个数为基准，将小于他的放左边，大于他的放右边+ 快排左数组 + 快排右数组，拼接三个部分
2. 递归条件：数组长度大于1

function quickSort(arr) {
  if (arr.length > 1) {
    let mid
    let left = []
    let right = []
    mid = arr.shift()
    for (let i = 0; i < arr.length; i++) {
      if (arr[i] <= mid) {
        left.push(arr[i])
      } else {
        right.push(arr[i])
      }
    }
    left = quickSort(left)
    right = quickSort(right)
    return left.concat(mid, right)
  } else if (arr.length === 1 || arr.length === 0) {
    return arr
  }
}
debugger
let arr = [3, 2, 1, 4, 6]
let result = quickSort(arr)
console.log(result)

性能分析

1. 时间复杂度： 挑选一个数字，跟整个数组比较，一共会挑选logN次，数组长度是N,故时间复杂度是N*logN

冒泡排序

1. 初始化
2. 循环条件：n轮冒泡，并且上一轮有位置交换
3. 每一轮做的事情，跟旁边元素比较交换位置，

function bubbleSort(arr) {
  let length = arr.length
  let needContinue = true
  let temp
  for (let i = 0; i < length && needContinue; i++) {
    // 一共要length轮冒泡，每一轮冒泡前都认为是正序，如果该轮出现交换才需要进行下一轮冒泡
    needContinue = false
    for (let j = 0; j < length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        temp = arr[j + 1]
        arr[j + 1] = arr[j]
        arr[j] = temp
        needContinue = true
      }
    }
  }
  return arr
}
let ori = [1, 2, 4, 1, 2, 6, 7, 9, 10, 7]
let sort = bubbleSort(ori)
console.log(sort)

插入排序

1. 初始化
2. n-1轮插入，如果逆序，找到正确的位置（就像是整理扑克牌顺序）
3. 每一轮处理的事情：将逆序元素暂存，大于它的元素位置后移

function InsertSort(arr) {
  let length = arr.length
  let temp
  let j
  for (let i = 1; i < length; i++) {
    if (arr[i] < arr[i - 1]) {
      temp = arr[i]
      // 如果能自定义数据解构，将原始arr[0]置空，每一轮把arr[i]放在arr[0],当作哨兵，可以去掉j>=0
      for (j = i - 1; arr[j] > temp && j >= 0; j--) {
        arr[j + 1] = arr[j]
      }
      arr[j] = temp
    }
  }
  return arr
}
let ori = [1, 2, 4, 1, 2, 6, 7, 9, 10, 7]
let sort = InsertSort(ori)
console.log(sort)