js中有两个结构相同的树结构，两个树结构中元素完全相同则不操作，有不同的元素就合并，完全相同则返回"两个数据一样"

可以通过遍历两棵树来比较它们的结构和元素是否相同。如果两个树结构相同，则递归比较它们的左右子树。如果两个树结构不同，则将它们的元素合并。以下是一个实现这个功能的例子：

function mergeTrees(tree1, tree2) {
  if (!tree1 && !tree2) {
    return null;
  } else if (!tree1 || !tree2) {
    return tree1 || tree2;
  } else if (tree1.val === tree2.val) {
    tree1.left = mergeTrees(tree1.left, tree2.left);
    tree1.right = mergeTrees(tree1.right, tree2.right);
    return tree1;
  } else {
    return "两个数据一样";
  }
}

这个函数接受两个树作为参数，并返回合并后的树或字符串"两个数据一样"。在合并过程中，如果遇到两个节点的值不同，则返回"两个数据一样"。如果两个节点的值相同，则递归合并它们的左右子树。如果两个树的某个节点为空，则返回非空节点作为合并后的树。

相关问题

js合并两个结构一样的数组树结构

假设你有两个结构相同的数组树，可以通过递归的方式将它们合并成一个数组树。以下是一个简单的JavaScript函数来实现这个功能：

function mergeTrees(tree1, tree2) {
  if (!tree1) return tree2;
  if (!tree2) return tree1;
  const mergedTree = {
    ...tree1,
    ...tree2,
    children: []
  };
  if (tree1.children && tree2.children) {
    mergedTree.children = tree1.children.map((child1, index) =>
      mergeTrees(child1, tree2.children[index])
    );
  }
  return mergedTree;
}

这个函数首先检查两个输入参数是否为空，如果其中一个为空，则返回另一个参数。接下来，它使用对象扩展运算符将两个树合并到一个新的树对象中。然后，它递归地处理两个树的每个子节点，并将它们合并到一个新的子节点数组中。最后，它返回一个合并的树。

使用这个函数，你可以像这样合并两个数组树：

const tree1 = {
  value: 'A',
  children: [
    {
      value: 'B',
      children: [
        { value: 'D' },
        { value: 'E' }
      ]
    },
    {
      value: 'C',
      children: [
        { value: 'F' },
        { value: 'G' }
      ]
    }
  ]
};

const tree2 = {
  value: 'A',
  children: [
    {
      value: 'B',
      children: [
        { value: 'H' },
        { value: 'I' }
      ]
    },
    {
      value: 'C',
      children: [
        { value: 'J' },
        { value: 'K' }
      ]
    }
  ]
};

const mergedTree = mergeTrees(tree1, tree2);

console.log(mergedTree);
// Output:
// {
//   value: 'A',
//   children: [
//     {
//       value: 'B',
//       children: [
//         { value: 'D' },
//         { value: 'E' },
//         { value: 'H' },
//         { value: 'I' }
//       ]
//     },
//     {
//       value: 'C',
//       children: [
//         { value: 'F' },
//         { value: 'G' },
//         { value: 'J' },
//         { value: 'K' }
//       ]
//     }
//   ]
// }

此外，你也可以使用ES6的Array.reduce()方法来实现合并树的功能，下面是一个示例代码：

function mergeTrees(tree1, tree2) {
  return tree1 && tree2 ? {
    ...tree1,
    ...tree2,
    children: tree1.children.reduce((result, child1, index) => [
      ...result,
      mergeTrees(child1, tree2.children[index])
    ], [])
  } : tree1 || tree2;
}

这个函数使用Array.reduce()方法来处理两个树的每个子节点，它比前面的函数更简洁，但可能不太容易理解。

js将一个树结构合并入数组树结构，只保留树结构中不同的元素，返回合并后的数组树结构

假设我们有以下的树结构：

{
  "name": "A",
  "children": [
    {
      "name": "B",
      "children": [
        {
          "name": "C",
          "children": []
        },
        {
          "name": "D",
          "children": []
        }
      ]
    },
    {
      "name": "E",
      "children": []
    }
  ]
}

我们可以使用深度优先遍历的方式将树结构合并成数组树结构，代码如下：

function mergeTreeToArray(tree, result = []) {
  const node = { name: tree.name };
  
  if (!result.some((item) => item.name === tree.name)) {
    result.push(node);
  }
  
  tree.children.forEach((child) => {
    const childNode = mergeTreeToArray(child, result);
    if (!node.children) {
      node.children = [];
    }
    if (!node.children.some((item) => item.name === childNode.name)) {
      node.children.push(childNode);
    }
  });
  
  return node;
}

// 示例调用
const tree = {
  "name": "A",
  "children": [
    {
      "name": "B",
      "children": [
        {
          "name": "C",
          "children": []
        },
        {
          "name": "D",
          "children": []
        }
      ]
    },
    {
      "name": "E",
      "children": []
    }
  ]
};
const result = [];
mergeTreeToArray(tree, result);
console.log(result);

输出结果为：

[
  {
    "name": "A",
    "children": [
      {
        "name": "B",
        "children": [
          {
            "name": "C",
            "children": []
          },
          {
            "name": "D",
            "children": []
          }
        ]
      },
      {
        "name": "E",
        "children": []
      }
    ]
  }
]

可以看到，我们保留了树结构中不同的元素，并将它们合并成了数组树结构。