数组相关方法

拍平：flat

const flatArray = function (arr) {
  return arr.reduce((reduceArr, item) => {
    if (Array.isArray(item)) {
      return [...reduceArr, ...flatArray(item)];
    } else {
      return [...reduceArr, item];
    }
  }, []);
};
flatArray([1, [2, 3], 4]);

排序

• 冒泡排序

原理：遍历数组，获得当前项，再遍历之后的所有项，若比当前项小，则不断的更新当前项为最小值。

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

• 选择排序

原理：类似冒泡排序，只不过不会即时的更换位置，而是查找到最小的值的下标，循环完毕后再更换位置

const selectionSort = function (arr) {
  const arrLength = arr.length;
  for (let i = 0; i < arrLength; i++) {
    let min = i;
    for (let j = i + 1; j < arrLength; j++) {
      if (arr[min] > arr[j]) {
        min = j;
      }
    }
    [arr[i], arr[min]] = [arr[min], arr[i]];
  }
  return arr;
};
selectSort([1, 23, 12, 35, 13, 5, 7, 4]);

• 插入排序

  原理：

  1. 发牌的时候，我们会得到零散的牌
  2. 从左往右查看，发现不大不小的牌则往前对比，比它大的往后推。
  3. 直到对比到比它小的牌，停止对比并放置在此处

const insertionSort = function (arr) {
  const arrLength = arr.length;
  for (let i = 1; i < arrLength; i++) {
    let prevIndex = i - 1;
    // 缓存当前位置的值（取出此牌）
    const current = arr[i];
    // 跟前一项对比
    while (prevIndex >= 0 && current < arr[prevIndex]) {
      // 比它大的往后推
      arr[prevIndex + 1] = arr[prevIndex];
      // 更新位置，继续跟前一项对比
      prevIndex--;
    }
    // 它的前一项不再比它大，结束对比，将此牌放在当前项。
    arr[prevIndex + 1] = current;
  }
  return arr;
};
insertionSort([1, 23, 12, 35, 13, 5, 7, 4]);

• 快速排序

  原理：

  1. 在数据集之中，选择一个元素作为"基准"（pivot）。
  2. 所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。
  3. 对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

const quickSort = function (arr) {
  if (arr.length <= 1) {
    return arr;
  }

  // 选择基准下标并取出
  const pivotIndex = Math.floor(arr.length / 2);
  const pivotVal = arr[pivotIndex];

  // 左边存放比基准小的，右边存放大的
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length; i++) {
    // 跳过基准判断
    if (i === pivotIndex) {
      continue;
    }
    if (arr[i] < pivotVal) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  // 递归
  return [...quickSort(left), pivotVal, ...quickSort(right)];
};

quickSort([1, 23, 12, 35, 13, 5, 7, 4]);

去重

/**
 * @method arrayUnique
 * @description 数组去重
 * @param {Array} arr
 * @return {Array}
 */
const arrayUnique = {
  base: function (arr) {
    const newArr = [];
    for (const item in arr) {
      if (!newArr.includes(item)) {
        newArr.push(item);
      }
    }
    return newArr;
  },
  bySet: function (arr) {
    return Array.from(new Set(arr));
  },
  byMap: function (arr) {
    const newArr = [];
    const map = new Map();
    for (const value of arr) {
      if (!map.has(value)) {
        map.set(value, true);
        newArr.push(value);
      }
    }
    map.clear();
    return newArr;
  },
};