数组相关

冒泡排序

let sortArr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 1];
const bubbleSort = (arr) => {
  let len = arr.length;
  if (len <= 1 ) { return arr; }
  let flag = true;
  for (let i = 0; i < len - 1 && flag; i++) {
    flag = false;
    for (let j = 0; j < len - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        flag = true;
      }
    }
  }
  return arr;
}
console.log(bubbleSort(sortArr));

插入排序

let sortArr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 1];
const insertSort = (arr) => {
  let len = arr.length;
  if (len <= 1) { return arr; }
  for (let i = 1; i < len; i ++) {
    for (let j = i; j > 0; j--) {
      if (arr[j] < arr[j - 1]) {
        [arr[j - 1], arr[j]] = [arr[j], arr[j - 1]]
      }
    }
  }
  return arr;
}
console.log(insertSort(sortArr));

快速排序

let sortArr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 1];
const quickSort = (arr) => {
  let len = arr.length;
  if (len <= 1) { return arr; }
  let middleIndex = Math.floor(len / 2),
    middle = arr.splice(middleIndex, 1)[0],
    leftArr = [],
    rightArr = [];
  for (let i = 0; i < len - 1; i++) {
    arr[i] < middle ? leftArr.push(arr[i]) : rightArr.push(arr[i]);
  }
  return quickSort(leftArr).concat(middle, quickSort(rightArr));
}

console.log(quickSort(sortArr));

数组扁平化： 多维数组转一维数组

let arr2 = [1, 2, [1, [2, 3, [4, 5, [6]]]]];
// 普通递归实现
const flatten = arr => {
  let result = [];
  arr.forEach(item => {
    result = result.concat(Array.isArray(item) ? fllaten(item) : item);
  });
  return result;
}

/*
reduce:
  arr.reduce(callback,[initialValue])
  callback （执行数组中每个值的函数，包含四个参数）
    1、previousValue （上一次调用回调返回的值，或者是提供的初始值（initialValue））
    2、currentValue （数组中当前被处理的元素）
    3、index （当前元素在数组中的索引）
    4、array （调用 reduce 的数组）
  initialValue （作为第一次调用 callback 的第一个参数。）
**/
const flatten2 = arr => {
  return arr.reduce((prev, cur) => {
    return prev.concat(Array.isArray(cur) ? flatten(cur) : cur);
  }, []);
}

// 利用 arr.some 判断当数组中还有数组的话，循环调用 flatten 扁平函数(利用 [].concat扁平), 用 concat 连接，最终返回 arr;
const flatten3 = arr => {
  while(arr.some(item => Array.isArray(item))) {
    arr = [].concat(...arr);
  }
  return arr;
}
console.log(flatten(arr2));

数组去重

let arr = [5, 2, 7, 8, 34, 7, 39, 12, 56, 1];

const removeRepeat = (arr = []) => {
  let newArr = [];
  for (let i = 0; i < arr.length; i++) {
    if (newArr.indexOf(arr[i]) === -1) {
      newArr.push(arr[i]);
    }
  }
  return newArr;
}

const removeRepeat2 = (arr = []) => {
  return [...new Set(arr)]
}

const removeRepeat3 = (arr = []) => {
  return arr.filter((item, index, arr) => {
    // 下标相等的返回，不相等的说明前边有相同数据了
    return arr.indexOf(item) == index;
  });
}
console.log(removeRepeat4(arr));

扁平化数组转树结构

/*  
let arr3 = [
  {id: 1, name: '部门1', pid: 0},
  {id: 2, name: '部门2', pid: 1},
  {id: 3, name: '部门3', pid: 1},
  {id: 4, name: '部门4', pid: 3},
  {id: 5, name: '部门5', pid: 4},
]
输出结果: 
[
  {
    "id": 1,
    "name": "部门1",
    "pid": 0,
    "children": [
      {
        "id": 2,
        "name": "部门2",
        "pid": 1,
        "children": []
      },
      {
        "id": 3,
        "name": "部门3",
        "pid": 1,
        "children": [
            // 结果 ,,,
        ]
      }
    ]
  }
]
**/

const getChildren = (arr, result, pid) => {
  arr.forEach(item => {
    if (item.pid === pid) {
      let newItem = { ...item, children: [] };
      result.push(newItem);
      getChildren(arr, newItem.children, item.id);
    }
  });
}
const arrayToTree = (arr, pid) => {
  let result = [];
  getChildren(arr, result, pid);
  return result;
}
console.log(arrayToTree(arr3, 0));