轻松掌握五种 JS 方法将平铺数组转换为嵌套数组或树状数组

2022-12-29 17:09:34

将数组转化为树结构：多种方法大比拼

在 JavaScript 编程中，转换数组为树结构是一个常见的需求。本文将介绍五种实现这一转换的常用方法，深入探讨其时间复杂度、空间复杂度和适用场景，并辅以丰富的代码示例。

1. 递归方法

递归方法是一种直观的转换方式。它以数组的第一个元素为树的根节点，然后递归地遍历数组的剩余元素，并将它们作为根节点的子节点。

代码示例：

const array = [1, 2, 3, 4, 5];

function convertToTree(array) {
  if (array.length === 0) {
    return null;
  }

  const root = array[0];
  const children = array.slice(1);

  return {
    root: root,
    children: convertToTree(children),
  };
}

const tree = convertToTree(array);
console.log(tree);

时间复杂度： O(n)，其中 n 为数组的长度。
空间复杂度： O(n)，递归调用带来的栈空间开销。
优点： 简单易懂，实现方便。
缺点： 递归深度过大时，可能会导致栈溢出错误。

2. 迭代方法

迭代方法是一种逐个元素迭代数组的方式。它从数组的第一个元素开始，将其作为根节点，然后依次遍历数组的剩余元素，并将它们作为根节点的子节点。

代码示例：

const array = [1, 2, 3, 4, 5];

function convertToTree(array) {
  if (array.length === 0) {
    return null;
  }

  const root = array[0];
  const tree = {
    root: root,
    children: [],
  };

  for (let i = 1; i < array.length; i++) {
    const child = array[i];
    tree.children.push(child);
  }

  return tree;
}

const tree = convertToTree(array);
console.log(tree);

时间复杂度： O(n)，其中 n 为数组的长度。
空间复杂度： O(n)，用于存储树结构的开销。
优点： 稳定可靠，不会出现栈溢出问题。
缺点： 代码稍显冗长，可读性不如递归方法。

3. 使用 Map 方法

Map 方法可以将键值对存储在一个对象中。我们可以利用 Map 方法，将数组的每个元素作为键，并将该元素的子元素作为值存储。这样就构建了一个键值对组成的树结构。

代码示例：

const array = [1, 2, 3, 4, 5];

function convertToTree(array) {
  if (array.length === 0) {
    return null;
  }

  const tree = new Map();

  for (let i = 0; i < array.length; i++) {
    const element = array[i];
    tree.set(element, []);
  }

  for (let i = 0; i < array.length; i++) {
    const element = array[i];
    const children = array.slice(i + 1).filter((child) => child > element);

    tree.get(element).push(...children);
  }

  return tree;
}

const tree = convertToTree(array);
console.log(tree);

时间复杂度： O(n^2)，嵌套循环导致的复杂度提升。
空间复杂度： O(n^2)，存储键值对和树结构的开销。
优点： 利用 Map 方法的键值特性，构建树结构更具灵活性。
缺点： 时间复杂度较高，不适合处理大型数组。

4. 使用 Set 方法

Set 方法可以存储唯一的值。我们可以利用 Set 方法，将树结构中的节点存储在 Set 中，然后利用 Set 的交集和差集操作构建树结构。

代码示例：

const array = [1, 2, 3, 4, 5];

function convertToTree(array) {
  if (array.length === 0) {
    return null;
  }

  const tree = new Set();

  for (let i = 0; i < array.length; i++) {
    const element = array[i];
    tree.add(element);
  }

  for (let i = 0; i < array.length; i++) {
    const element = array[i];
    const children = array.slice(i + 1).filter((child) => child > element);

    const intersection = new Set(children).intersection(tree);
    const difference = new Set(children).difference(intersection);

    tree.delete(...difference);
  }

  return tree;
}

const tree = convertToTree(array);
console.log(tree);

时间复杂度： O(n^2)，嵌套循环导致的复杂度提升。
空间复杂度： O(n^2)，存储 Set 和树结构的开销。
优点： 利用 Set 方法的唯一值特性，构建树结构更具可靠性。
缺点： 时间复杂度较高，不适合处理大型数组。

5. 使用 Array.from 方法

Array.from 方法可以将类数组对象转换为真正的数组。我们可以利用 Array.from 方法，将树结构中的节点转换为真正的数组，然后利用 Array.from 方法的 flatMap 方法构建树结构。

代码示例：

const array = [1, 2, 3, 4, 5];

function convertToTree(array) {
  if (array.length === 0) {
    return null;
  }

  const tree = Array.from(array);

  for (let i = 0; i < array.length; i++) {
    const element = array[i];
    const children = array.slice(i + 1).filter((child) => child > element);

    tree.push(...children);
  }

  return Array.from(tree).flatMap((element) => convertToTree([element]));
}

const tree = convertToTree(array);
console.log(tree);