排序算法

一、选择排序

从左到右依次遍历，每次遍历选择出一个极值存起来，再在剩下的元素中遍历
时间复杂度：n^2

function select(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    let min = arr[i];
    for (let j = i; j < arr.length; j++) {
      if (min > arr[j]) {
        [min, arr[j]] = [arr[j], min];
      }
    }
    arr[i] = min;
  }
  return arr;
}

二、冒泡排序

从左到右，两两比较，每次遍历都能确定一个最右边的值
时间复杂度：n^2

function bubble(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  return arr;
}

三、快速排序

指定一个基准值，比基准值小的放到左边，比基准值大的放到右边，这样每次都能固定基准值的位置。
时间复杂度：nlog2n

function quick(arr) {
  //  当数组只有一个元素时，直接返回
  if (arr.length <= 1) {
    return arr;
  }
  //   指定基准索引
  let pivotIndex = Math.floor(arr.length / 2);
  //   取出基准值
  let pivot = arr.splice(pivotIndex, 1)[0];
  //   定义两个数组
  let left = [];
  let right = [];
  //   比基准值小的放到left,比基准值大的放到right
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  //  合并
  return quick(left).concat([pivot], quick(right));
}

四、计数排序

采用哈希表，用空间换时间
时间复杂度：n+max-min

function count(arr) {
  //  当数组只有一个元素时，直接返回
  let max = (min = arr[0]),
    hashTable = {},
    result = [];
  // 将arr的元素放到hashTable里
  for (let i = 0; i < arr.length; i++) {
    if (!(arr[i] in hashTable)) {
      hashTable[arr[i]] = 1;
    } else {
      hashTable[arr[i]] += 1;
    }
    // 找到数组的最大值max
    if (arr[i] > max) {
      max = arr[i];
    }
    // 找到数组的最小值min
    if (arr[i] < min) {
      min = arr[i];
    }
  }
  // 将hashTable的key放到要返回的result数组中
  for (let j = min; j <= max; j++) {
    if (j in hashTable) {
      for (let i = 0; i < hashTable[j]; i++) {
        result.push(j);
      }
    }
  }
  return result;
}