617. Merge Two Binary Trees

617. Merge Two Binary Trees

// iterative 

Approach #2 Iterative Method [Accepted]

Algorithm

In the current approach, we again traverse the two trees, but this time we make use of a stackstack to do so instead of making use of recursion. Each entry in the stackstack strores data in the form [node_{tree1}, node_{tree2}][nodetree1​,nodetree2​]. Here, node_{tree1}nodetree1​ and node_{tree2}nodetree2​ are the nodes of the first tree and the second tree respectively.

We start off by pushing the root nodes of both the trees onto the stackstack. Then, at every step, we remove a node pair from the top of the stack. For every node pair removed, we add the values corresponding to the two nodes and update the value of the corresponding node in the first tree. Then, if the left child of the first tree exists, we push the left child(pair) of both the trees onto the stack. If the left child of the first tree doesn't exist, we append the left child(subtree) of the second tree to the current node of the first tree. We do the same for the right child pair as well.

If, at any step, both the current nodes are null, we continue with popping the next nodes from the stackstack.

The following animation depicts the process.

public class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if (t1 == null)
            return t2;
        Stack < TreeNode[] > stack = new Stack < > ();
        stack.push(new TreeNode[] {t1, t2});
        while (!stack.isEmpty()) {
            TreeNode[] t = stack.pop();
            if (t[0] == null || t[1] == null) {
                continue;
            }
            t[0].val += t[1].val;
            if (t[0].left == null) {
                t[0].left = t[1].left;
            } else {
                stack.push(new TreeNode[] {t[0].left, t[1].left});
            }
            if (t[0].right == null) {
                t[0].right = t[1].right;
            } else {
                stack.push(new TreeNode[] {t[0].right, t[1].right});
            }
        }
        return t1;
    }
}

• Time complexity : O(n) We traverse over a total of nn nodes. Here, nn refers to the smaller of the number of nodes in the two trees.

• Space complexity : O(n). The depth of stack can grow upto nn in case of a skewed tree.

 

// recursive

class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
      if (t1 == null && t2 == null) return null;

      if(t1 == null) return t2;
      if(t2 == null) return t1;
      
      TreeNode newRoot = new TreeNode(t1.val + t2.val);
      newRoot.left = mergeTrees(t1.left, t2.left);
      newRoot.right = mergeTrees(t1.right, t2.right);
      return newRoot;       
    }
}

• Time complexity : O(m)A total of mm nodes need to be traversed. Here, mm represents the minimum number of nodes from the two given trees.

• Space complexity : O(m) The depth of the recursion tree can go upto mm in the case of a skewed tree. In average case, depth will be O(logm)O(logm).

---

Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.

You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.

Example 1:

Input: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
Output: 
Merged tree:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   7

 

Note: The merging process must start from the root nodes of both trees.