基础排序

基础排序

• 冒泡排序
• 选择排序
• 插入排序
• 归并排序
• 快速排序

需求

输入：[8, 4, 2, 1, 9]
输出：[1, 2, 4, 8, 9]

冒泡排序

核心：两两交换
思路：

• 一个数对比 n-1 次，有 n 个
• 将自身与下一个对比，大了或小了换

const bubbleSort = (arr) => {
  for(let i = 0; i < arr.length; i++) {
    for(let j = 0; j < arr.length; j++) {
      if(arr[j] > arr[j+1]) {
        swap(arr, j, j+1)
      }
    }
  }
  return arr;
}
const swap = (arr, i, j) => (
  [arr[i], arr[j]] = [arr[j], arr[i]]
)
// test
const _arr = [8, 4, 2, 1, 9];
console.log(bubbleSort(_arr)); // [1, 2, 4, 8, 9]

选择排序

核心：（和待排比）选出待排最大或最小的，放在已排后面
思路：

• 遍历，拿最小的记住下标（假定一个，然后一一对比）
• 将假定的比对后记住的对调

const selectionSort = (arr) => {
  for(let i in arr) {
    let min = i;
    for(let j = Number(i)+1; j < arr.length; j++) {
      if(arr[min] > arr[j]) {
        min = j;
      }
    }
    if(min !== i) {
     swap(arr, min ,i);
    }
  }
  return arr;
}
const swap = (arr, i, j) => (
  [arr[i], arr[j]] = [arr[j], arr[i]]
)
// test
const _arr = [8, 4, 2, 1, 9];
console.log(selectionSort(_arr)); // [1, 2, 4, 8, 9]

插入排序

核心：（和已排比）拿出一个逐个对比已排，默认第一个有序
思路：

• 构造一个已排队列，默认第一个有序
• 遍历数据，将其一一对已排队列比对，若大或小，则挪动腾出左侧位置

const insertSort = (arr) => {
  for(let i = 1; i < arr.length; i++) {
    let target = arr[i]
    let j = i;
    while(j > 0 && arr[j-1] > target) {
      arr[j] = arr[j-1];
      j--;
    }
    arr[j] = target;
  }
  return arr;
}
// test
const _arr = [8, 4, 2, 1, 9];
console.log(insertSort(_arr)); // [1, 2, 4, 8, 9]

归并排序

核心：(按数量割)分-归-并
思路：

• 分：找分隔点，分到不可分隔为止
• 归并：从最小元素开始比对合并

const mergeSort = (arr) => {
  if(arr.length < 2) {
    return arr;
  }
  const m = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, m));
  const right = mergeSort(arr.slice(m));
  return merge(left, right);
}
const merge = (left, right) => {
  const r = [];
  let i = 0;
  let j = 0;
  while(i < left.length && j < right.length) {
    if(left[i] <= right[j]) {
      r.push(left[i++])
    } else {
      r.push(right[j++])
    }
  }
  if(i < left.length) {
    r.push(...left.slice(i))
  } else {
    r.push(...right.slice(j))
  }
  return r;
}
// test
const _arr = [8, 4, 2, 1, 9];
console.log(mergeSort(_arr)); // [1, 2, 4, 8, 9]

快速排序

核心：（按大小割）归并，拿一个参考数（可以是最后一个），小于它放左边，大于放右边
思路：

const quickSort = (arr) => {
  if(arr.length < 2){
    return arr;
  }
  const pivot = arr[arr.length - 1];
  const left = arr.filter((v, i) => v <= pivot && i !== arr.length -1);
  const right = arr.filter(v => v > pivot);
  return [...quickSort(left), pivot, ...quickSort(right)]
}
// test
const _arr = [8, 4, 2, 1, 9];
console.log(quickSort(_arr)); // [1, 2, 4, 8, 9]