给定两个二叉树,想象当你将它们中的一个覆盖到另一个上时,两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠,那么将他们的值相加作为节点合并后的新值,否则不为 NULL 的节点将直接作为新二叉树的节点。
注意: 合并必须从两个树的根节点开始。
一:深度优先搜索(递归)
依据为二叉树的先序递归实现:
从根节点开始同时遍历两个二叉树,并将对应的节点进行合并。
合并时:判断两个节点都为空,则返回null;如果两个节点均不为空,则返回value值相加后的节点;如果仅一个为空,那么返回不为空的节点; 对当前判断节点的孩子继续进行递归判断。
public static TreeNode mergeTree(TreeNode t1,TreeNode t2){
if(t1==null){
return t2;
}
if(t2==null){
return t1;
}
TreeNode root = new TreeNode(t1.val+t2.val);
root.left = mergeTree(t1.left,t2.left);
root.right = mergeTree(t1.right,t2.right);
return root;
}
时间复杂度为:O(min(m,n))
空间复杂度为:O(min(m,n))
二:广度优先搜索(非递归 借助队列实现)
不生成新的树,在第一棵树的基础上进行操作
(生成新树的操作同理,只需建立新的root根即可)
1,如果树1的左子节点为空,直接把第2棵树的左子节点赋给第1棵树的左子节点即可
2,如果树1的左子节点不为空,树2的左子节点为空,直接返回树1的左子节点即可
3,如果树1的左子节点和树2的左子节点都不为空,直接相加,
public static TreeNode mergeTree(TreeNode t1,TreeNode t2){
// t1为空,返回t2
if(t1==null){
return t2;
}
// t2为空,返回t1
if(t2==null){
return t1;
}
// 定义队列,t1t2不为空 t1,t2入队
Queue<TreeNode> queue = new LinkedList<>();
queue.add(t1);
queue.add(t2);
while (!queue.isEmpty()){
//t1,t2依次出队
TreeNode node1 = queue.poll();
TreeNode node2 = queue.poll();
// 两个节点的值相加,合并到第1棵树的节点上
node1.val += node2.val;
// 对第一棵树的左子树判断,如果为空,则把第二棵树的左子树加到第一棵树上
if(node1.left==null){
node1.left = node2.left;
}else {
//如果第二棵树的左子树为空,对结果无影响
//如果两棵树左子树均不为空,入队
if(node2.left!=null){
queue.add(node1.left);
queue.add(node2.left);
}
}
//右子树判断同上
if(node1.right==null){
node1.right = node2.right;
}else {
if(node2.right!=null){
queue.add(node1.right);
queue.add(node2.right);
}
}
}
return t1;
}
//不对原树进行操作,借助三个队列进行实现,对新树的操作借助一个Queue来实现
public static TreeNode mergeTrees_2(TreeNode t1, TreeNode t2){
if (t1 == null) {
return t2;
}
if (t2 == null) {
return t1;
}
TreeNode merged = new TreeNode(t1.val + t2.val);
Queue<TreeNode> queue = new LinkedList<TreeNode>();
Queue<TreeNode> queue1 = new LinkedList<TreeNode>();
Queue<TreeNode> queue2 = new LinkedList<TreeNode>();
queue.offer(merged);
queue1.offer(t1);
queue2.offer(t2);
while (!queue1.isEmpty() && !queue2.isEmpty()) {
TreeNode node = queue.poll(), node1 = queue1.poll(), node2 = queue2.poll();
TreeNode left1 = node1.left, left2 = node2.left, right1 = node1.right, right2 = node2.right;
if (left1 != null || left2 != null) {
if (left1 != null && left2 != null) {
TreeNode left = new TreeNode(left1.val + left2.val);
node.left = left;
queue.offer(left);
queue1.offer(left1);
queue2.offer(left2);
} else if (left1 != null) {
node.left = left1;
} else if (left2 != null) {
node.left = left2;
}
}
if (right1 != null || right2 != null) {
if (right1 != null && right2 != null) {
TreeNode right = new TreeNode(right1.val + right2.val);
node.right = right;
queue.offer(right);
queue1.offer(right1);
queue2.offer(right2);
} else if (right1 != null) {
node.right = right1;
} else {
node.right = right2;
}
}
}
return merged;
}
时间复杂度为:O(min(m,n))
空间复杂度为:O(min(m,n))