js 树状结构和数组正推反推

一花一world

已于 2023-07-11 17:01:59 修改

阅读量327

点赞数

分类专栏：前端文章标签： javascript 开发语言 ecmascript

于 2023-07-11 16:52:32 首次发布

本文链接：https://blog.csdn.net/ACCPluzhiqi/article/details/131664045

版权

前端专栏收录该内容

178 篇文章 31 订阅

订阅专栏

树状结构和数组之间的相互转换可以通过正推和反推两种方式实现。

正推（树状结构转换为数组）：

先定义一个空数组，用于存储树的节点值。
使用深度优先搜索（DFS）或广度优先搜索（BFS）遍历树的节点。
遍历到每个节点时，将节点的值添加到数组中。
遍历完成后，数组中的元素顺序就是树的节点值的顺序。

反推（数组转换为树状结构）：

先确定树的根节点，可以选择数组的中间元素作为根节点。
创建根节点，并将数组中间元素的值赋给根节点。
将数组分为左子数组和右子数组，分别对应根节点的左子树和右子树。
递归地将左子数组和右子数组转换为左子树和右子树，并将它们分别连接到根节点的左子节点和右子节点上。
递归过程中，不断缩小数组的范围，直到数组为空或只有一个元素。
最终得到的根节点就是完整的树。

需要注意的是，树状结构和数组之间的转换并不是唯一的，具体的实现方式可以根据实际需求和数据结构的特点进行选择。在转换过程中，需要考虑树的遍历顺序、根节点的选择、数组的分割方式等因素。同时，转换过程中可能需要使用递归或迭代等方法来处理树的节点和数组的元素。

转换示例

在JavaScript中，可以使用多种方法将树状结构和数组相互转换。下面给出了几种常用的方法。

1. 先序遍历 + 递归：

class TreeNode {
  constructor(val = 0, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

// 将树状结构转换为数组（先序遍历）
function treeToArray(root) {
  const result = [];
  if (!root) {
    return result;
  }
  
  function traverse(node) {
    if (!node) {
      return;
    }
    result.push(node.val);
    traverse(node.left);
    traverse(node.right);
  }
  
  traverse(root);
  return result;
}

// 将数组转换为树状结构
function arrayToTree(nums) {
  if (!nums.length) {
    return null;
  }
  
  function buildTree(left, right) {
    if (left > right) {
      return null;
    }
    
    const mid = Math.floor((left + right) / 2);
    const root = new TreeNode(nums[mid]);
    root.left = buildTree(left, mid - 1);
    root.right = buildTree(mid + 1, right);
    return root;
  }
  
  return buildTree(0, nums.length - 1);
}

使用示例：

// 创建树
const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);

// 将树状结构转换为数组
const arr = treeToArray(root);
console.log(arr);  // 输出: [1, 2, 4, 5, 3]

// 将数组转换为树状结构
const tree = arrayToTree(arr);
console.log(tree);  // 输出: 树状结构

2. 先序遍历 + 迭代：

class TreeNode {
  constructor(val = 0, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

// 将树状结构转换为数组（先序遍历）
function treeToArray(root) {
  const result = [];
  if (!root) {
    return result;
  }
  
  const stack = [root];
  while (stack.length) {
    const node = stack.pop();
    result.push(node.val);
    if (node.right) {
      stack.push(node.right);
    }
    if (node.left) {
      stack.push(node.left);
    }
  }
  
  return result;
}

// 将数组转换为树状结构
function arrayToTree(nums) {
  if (!nums.length) {
    return null;
  }
  
  function buildTree(left, right) {
    if (left > right) {
      return null;
    }
    
    const mid = Math.floor((left + right) / 2);
    const root = new TreeNode(nums[mid]);
    root.left = buildTree(left, mid - 1);
    root.right = buildTree(mid + 1, right);
    return root;
  }
  
  return buildTree(0, nums.length - 1);
}

使用示例与上面的示例相同。

这里使用了先序遍历的方式将树状结构转换为数组，以及使用了迭代的方式进行先序遍历。数组转换为树状结构的方法与上面的示例相同。
是的，还有其他方法可以处理树状结构和数组的相互转换。下面介绍一种常见的方法：

3. 层序遍历：

class TreeNode {
  constructor(val = 0, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

// 将树状结构转换为数组（层序遍历）
function treeToArray(root) {
  const result = [];
  if (!root) {
    return result;
  }
  
  const queue = [root];
  while (queue.length) {
    const node = queue.shift();
    result.push(node.val);
    if (node.left) {
      queue.push(node.left);
    }
    if (node.right) {
      queue.push(node.right);
    }
  }
  
  return result;
}

// 将数组转换为树状结构
function arrayToTree(nums) {
  if (!nums.length) {
    return null;
  }
  
  const root = new TreeNode(nums[0]);
  const queue = [root];
  let i = 1;
  
  while (i < nums.length) {
    const node = queue.shift();
    
    if (nums[i] !== null) {
      node.left = new TreeNode(nums[i]);
      queue.push(node.left);
    }
    i++;
    
    if (i < nums.length && nums[i] !== null) {
      node.right = new TreeNode(nums[i]);
      queue.push(node.right);
    }
    i++;
  }
  
  return root;
}