js 数组转换和常用排序

// 多维数组转一维数组
export const flatten = arr =>
  arr.reduce(
    (acc, val) => acc.concat(Array.isArray(val) ? flatten(val) : val),
    []
  );

/**
 * 一维数组转二维数组
 * @param {*} arr 数组
 * @param {*} num 需要转换二维数组的长度
 */
export const oneTogether = (arr, num = 4) => {
  const len = arr.length;
  const lineNum = len % num === 0 ? len / num : Math.floor(len / num + 1);
  let newArray = [];
  for (let i = 0; i < lineNum; i++) {
    // slice() 方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。且原始数组不会被修改。
    const temp = arr.slice(i * num, i * num + num);
    newArray.push(temp);
  }
  return newArray;
};

/**
 * 数组去重
 * @param {*} arr 数组
 */
export const arrayStore = arr => {
  const array = arr.sort();
  let newArray = [];
  for (let i = 0; i < array.length; i++) {
    for (let j = i + 1; j < array.length; j++) {
      if (array[i] === array[j]) ++i;
    }
    newArray.push(array[i]);
  }
  return newArray;
};

/**
 * 数组冒泡排序
 * @param {*} arr 数组
 */
export const bubbleSort = arr => {
  const length = arr.length;
  if (length > 1) {
    //n个数的数组需要排序（n-1）轮
    for (let i = 0; i < length - 1; i++) {
      //每一轮比较的次数逐次递减
      for (let j = 0; j < length - 1 - i; j++) {
        let a = 0;
        if (arr[j] > arr[j + 1]) {
          a = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = a;
        }
      }
    }
  }
  return arr;
};

/**
 * 数组快速排序
 * @param {数组} arr
 */
export const fastSort = arr => {
  const length = arr.length;
  if (length <= 1) return arr;

  //找到基准点并删除该数
  let index = Math.floor(length / 2);
  let base = arr.splice(index, 1)[0];
  let left = [];
  let right = [];
  //把数组按基准点分成两个子数组
  for (let i = 0; i < arr.length; i++) {
    let val = arr[i];
    if (val > base) {
      right.push(val);
    } else {
      left.push(val);
    }
  }
  //递归
  return quickSort(left).concat([base], quickSort(right));
};