export const flattenArr = (arr: any[]) => {
  return arr.reduce((prev, next) => {
    return prev.concat(Array.isArray(next) ? flattenArr(next) : next);
  }, [])
}

export const treeArr = (data: any[]) => {
  let result: any[] = []
  if (!Array.isArray(data)) {
    return result
  }
  data.forEach(item => {
    delete item.children;
  });
  let map = {};
  data.forEach(item => {
    map[item.id] = item;
  });
  data.forEach(item => {
    let parent = map[item.pid];
    if (parent) {
      (parent.children || (parent.children = [])).push(item);
    } else {
      result.push(item);
    }
  });
  return result;
}

export const quickSort = (array: any[]) => {
  const sort = (arr, left = 0, right = arr.length - 1) => {
    if (left >= right) {//如果左边的索引大于等于右边的索引说明整理完毕
      return
    }
    let i = left
    let j = right
    const baseVal = arr[j] // 取无序数组最后一个数为基准值
    while (i < j) { //把所有比基准值小的数放在左边大的数放在右边
      while (i < j && arr[i] <= baseVal) { //找到一个比基准值大的数交换
        i++
      }
      arr[j] = arr[i] // 将较大的值放在右边如果没有比基准值大的数就是将自己赋值给自己（i 等于 j）
      while (j > i && arr[j] >= baseVal) { //找到一个比基准值小的数交换
        j--
      }
      arr[i] = arr[j] // 将较小的值放在左边如果没有找到比基准值小的数就是将自己赋值给自己（i 等于 j）
    }
    arr[j] = baseVal // 将基准值放至中央位置完成一次循环（这时候 j 等于 i ）
    sort(arr, left, j - 1) // 将左边的无序数组重复上面的操作
    sort(arr, j + 1, right) // 将右边的无序数组重复上面的操作
  }
  const newArr = array.concat() // 为了保证这个函数是纯函数拷贝一次数组
  sort(newArr)
  return newArr
}

export const quickEasySort = (arr: any[]) => {
  if (arr.length <= 1) {
    return arr;
  }
  var left: any[] = [],
    right: any[] = [],
    k = arr.splice(0, 1)[0];
  for (let i: number = 0; i < arr.length; i++) {
    if (arr[i] > k) {
      right.push(arr[i]);
    } else {
      left.push(arr[i]);
    }
  }
  return quickEasySort(left).concat([k], quickEasySort(right));
}