数据扁平化

要展平嵌套数组的数组，可以使用flat（）方法。此方法创建一个新数组，其中所有子数组元素递归连接到指定深度。 下面是一个例子：

const nestedArr = [1, 2, [3, 4, [5, 6]]];
const flattenedArr = nestedArr.flat(2);
console.log(flattenedArr); // [1, 2, 3, 4, 5, 6]

如果需要用嵌套对象展平对象，可以使用递归函数展平每个嵌套对象，并将它们合并为一个对象。下面是一个例子：

function flattenObject(obj) {
  const flattened = {};
  Object.keys(obj).forEach((key) => {
    if (typeof obj[key] === 'object' && obj[key] !== null) {
      Object.assign(flattened, flattenObject(obj[key]));
    } else {
      flattened[key] = obj[key];
    }
  });
  return flattened;
}

const nestedObj = {
  a: 1,
  b: {
    c: 2,
    d: {
      e: 3,
    },
  },
};

const flattenedObj = flattenObject(nestedObj);
console.log(flattenedObj); // { a: 1, c: 2, e: 3 }

要展平树，可以使用递归函数遍历树，并将每个节点展平为单个数组。下面是一个例子：

以下是flattenTree函数的一个实现，其时间复杂度为O（n）：

function flattenTree(node) {
  const flattened = [];
  const stack = [node];
  while (stack.length > 0) {
    const current = stack.pop();
    flattened.push(current.value);
    if (current.children) {
      for (let i = current.children.length - 1; i >= 0; i--) {
        stack.push(current.children[i]);
      }
    }
  }
  return flattened;
}

const tree = {
  value: 1,
  children: [
    {
      value: 2,
      children: [
        {
          value: 3,
          children: [
            {
              value: 4,
            },
          ],
        },
        {
          value: 5,
        },
      ],
    },
    {
      value: 6,
    },
  ],
};

const flattenedTree = flattenTree(tree);
console.log(flattenedTree); // [1, 2, 3, 4, 5, 6]

在这个实现中，flattenTree函数使用堆栈来执行树的深度优先遍历。该函数初始化一个空的扁平数组和一个包含根节点的堆栈。然后，函数进入一个循环，该循环一直持续到堆栈为空。在循环的每次迭代中，函数都会从堆栈中弹出顶部节点，将其值添加到扁平数组中，并按相反的顺序将其子节点推到堆栈上（这样第一个子节点就在堆栈的顶部）。这样可以确保函数以正确的顺序访问节点，以生成扁平阵列。 这种实现的时间复杂度为O（n），其中n是树中节点的总数，因为它只访问每个节点一次，并对每个节点执行恒定的时间操作。

使用递归遍历数进行扁平化 O（n）

function flattenTree(node) {
  const flattened = [node.value];
  if (node.children) {
    node.children.forEach((child) => {
      flattened.push(...flattenTree(child));
    });
  }
  return flattened;
}

const tree = {
  value: 1,
  children: [
    {
      value: 2,
      children: [
        {
          value: 3,
          children: [
            {
              value: 4,
            },
          ],
        },
        {
          value: 5,
        },
      ],
    },
    {
      value: 6,
    },
  ],
};

const flattenedTree = flattenTree(tree);
console.log(flattenedTree); // [1, 2, 3, 4, 5, 6]

在本例中，flattenTree函数将节点对象作为输入，并返回一个扁平值数组。函数首先将当前节点的值添加到展平的数组中。如果节点有子节点，函数会在每个子节点上递归调用自己，并使用spread运算符（…）将扁平的子数组扩展到扁平的数组中。最后，函数会返回扁平的数组。

一般来说，递归函数和基于堆栈的迭代函数是最常用的扁平化多维树的方法，因为它们既易于实现，又具有最佳的时间复杂度。然而，方法的选择可能取决于用例的具体要求，例如内存约束或扁平阵列的所需顺序。