617. Merge Two Binary Trees

617/step1.cpp

@@ -0,0 +1,28 @@
+/*
+Solve Time : 09:16
+
+Time : O(V)
+Space : O(V)
+
+rootの宣言周りのミスで無駄に手間取ってしまった。
+newをつかうべきだったがそれを失念していた。
+それ以外は特に問題なくクリア、気分的にとりあえず再帰で解いた。
+*/
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1 && !root2) {
+      return nullptr;
+    }
+    if (!root1) {
+      return root2;
+    } 
+    if (!root2) {
+      return root1;
+    }
+    TreeNode *root = new TreeNode(root1->val + root2->val);
+    root->left = mergeTrees(root1->left, root2->left);
+    root->right = mergeTrees(root1->right, root2->right);
+    return root;
+  }
+};

617/step2_0.cpp

@@ -0,0 +1,55 @@
+/*
+Time : O(V)
+Space : O(V)
+
+step2_1の改良前
+*/
+
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1 && !root2) {
+      return nullptr;
+    }
+    stack<pair<vector<TreeNode*>, bool>> next_nodes;
+    auto merged_root = new TreeNode();
+    if (root1) {
+      merged_root->val += root1->val;
+    }
+    if (root2) {
+      merged_root->val += root2->val;
+    }
+    next_nodes.push({{(root1 ? root1->left : nullptr), (root2 ? root2->left : nullptr), merged_root}, true});
+    next_nodes.push({{(root1 ? root1->right : nullptr), (root2 ? root2->right : nullptr), merged_root}, false});
+    while (!next_nodes.empty()) {
+      auto [nodes, is_left] = next_nodes.top();
+      next_nodes.pop();
+      auto node1 = nodes[0];
+      auto node2 = nodes[1];
+      auto parent_node = nodes[2];
+      if (!node1 && !node2) {
+        continue;
+      }
+      int merged_val = (node1 ? node1->val : 0) + (node2 ? node2->val : 0);
+      auto merged_node = new TreeNode(merged_val);
+      if (is_left) {
+        parent_node->left = merged_node;
+      } else {
+        parent_node->right = merged_node;
+      }
+      if (!node2) {
+        next_nodes.push({{node1->left, nullptr, merged_node}, true});
+        next_nodes.push({{node1->right, nullptr, merged_node}, false});
+        continue;
+      }
+      if (!node1) {
+        next_nodes.push({{nullptr, node2->left, merged_node}, true});
+        next_nodes.push({{nullptr, node2->right, merged_node}, false});
+        continue;
+      }
+      next_nodes.push({{node1->left, node2->left, merged_node}, true});
+      next_nodes.push({{node1->right, node2->right, merged_node}, false});
+    }
+    return merged_root;
+  }
+};

617/step2_1.cpp

@@ -0,0 +1,45 @@
+/*
+Time : O(V)
+Space : O(V)
+
+再帰を用いない方法で書いてみる。
+参考館演算子は普段なるべく使わないが、使うとnulptr考慮がかなりスッキリかけたので利用する。
+*/
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1 && !root2) {
+      return nullptr;
+    }
+    stack<pair<vector<TreeNode*>, bool>> next_nodes;
+    auto merged_root = new TreeNode();
+    if (root1) {
+      merged_root->val += root1->val;
+    }
+    if (root2) {
+      merged_root->val += root2->val;
+    }
+    next_nodes.push({{(root1 ? root1->left : nullptr), (root2 ? root2->left : nullptr), merged_root}, true});
+    next_nodes.push({{(root1 ? root1->right : nullptr), (root2 ? root2->right : nullptr), merged_root}, false});
+    while (!next_nodes.empty()) {
+      auto [nodes, is_left] = next_nodes.top();
+      next_nodes.pop();
+      auto node1 = nodes[0];
+      auto node2 = nodes[1];
+      auto parent_node = nodes[2];
+      if (!node1 && !node2) {
+        continue;
+      }
+      int merged_val = (node1 ? node1->val : 0) + (node2 ? node2->val : 0);
+      auto merged_node = new TreeNode(merged_val);
+      if (is_left) {
+        parent_node->left = merged_node;
+      } else {
+        parent_node->right = merged_node;
+      }
+      next_nodes.push({{(node1 ? node1->left : nullptr), (node2 ? node2->left : nullptr), merged_node}, true});
+      next_nodes.push({{(node1 ? node1->right : nullptr), (node2 ? node2->right : nullptr), merged_node}, false});
+    }
+    return merged_root;
+  }
+};

617/step2_2.cpp

@@ -0,0 +1,30 @@
+/*
+Time : O(V)
+Space : O(V)
+
+ポインタを用いて簡略化したもの
+*/
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1 && !root2) {
+      return nullptr;
+    }
+    stack<tuple<TreeNode*, TreeNode*, TreeNode**>> next_nodes;
+    auto merged_root = new TreeNode();
+    next_nodes.push({root1, root2, &merged_root});
+    while (!next_nodes.empty()) {
+      auto [node1, node2, merged_node_ptr] = next_nodes.top();
+      next_nodes.pop();
+      if (!node1 && !node2) {
+        continue;
+      }
+      int merged_val = (node1 ? node1->val : 0) + (node2 ? node2->val : 0);
+      TreeNode* merged_node = new TreeNode(merged_val);
+      *merged_node_ptr = merged_node;
+      next_nodes.push({(node1 ? node1->left : nullptr), (node2 ? node2->left : nullptr), &merged_node->left});
+      next_nodes.push({(node1 ? node1->right : nullptr), (node2 ? node2->right : nullptr), &merged_node->right});
+    }
+    return merged_root;
+  }
+};

617/step2_3.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1 && !root2) {
+      return nullptr;
+    }
+    stack<pair<vector<TreeNode*>, bool>> next_nodes;
+    auto merged_root = new TreeNode();
+    if (!root1) {
+      root1 = new TreeNode();
+    }
+    if (!root2) {
+      root2 = new TreeNode();
+    }
+    merged_root->val += root1->val + root2->val;
+    next_nodes.push({{root1->left, root2->left, merged_root}, true});
+    next_nodes.push({{root1->right, root2->right, merged_root}, false});
+    while (!next_nodes.empty()) {
+      auto [nodes, is_left] = next_nodes.top();
+      next_nodes.pop();
+      auto node1 = nodes[0];
+      auto node2 = nodes[1];
+      auto parent_node = nodes[2];
+      if (!node1 && !node2) {
+        continue;
+      }
+      int merged_val = (node1 ? node1->val : 0) + (node2 ? node2->val : 0);
+      auto merged_node = new TreeNode(merged_val);
+      if (is_left) {
+        parent_node->left = merged_node;
+      } else {
+        parent_node->right = merged_node;
+      }
+      next_nodes.push({{(node1 ? node1->left : nullptr), (node2 ? node2->left : nullptr), merged_node}, true});
+      next_nodes.push({{(node1 ? node1->right : nullptr), (node2 ? node2->right : nullptr), merged_node}, false});
+    }
+    return merged_root;
+  }
+};

617/step2_4.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1 && !root2) {
+      return nullptr;
+    }
+    stack<tuple<TreeNode*, TreeNode*, TreeNode**>> next_nodes;
+    TreeNode* merged_root;
+    next_nodes.push({root1, root2, &merged_root});
+    while (!next_nodes.empty()) {
+      auto [node1, node2, merged_node_ptr] = next_nodes.top();
+      next_nodes.pop();
+      if (!node1 && !node2) {
+        continue;
+      }
+      int merged_val = (node1 ? node1->val : 0) + (node2 ? node2->val : 0);
+      TreeNode* merged_node = new TreeNode(merged_val);
+      *merged_node_ptr = merged_node;
+      next_nodes.push({(node1 ? node1->left : nullptr), (node2 ? node2->left : nullptr), &merged_node->left});
+      next_nodes.push({(node1 ? node1->right : nullptr), (node2 ? node2->right : nullptr), &merged_node->right});
+    }
+    return merged_root;
+  }
+};

617/step3.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+  TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+    if (!root1) {
+      return root2;
+    }
+    if (!root2) {
+      return root1;
+    }
+    TreeNode* node = new TreeNode(root1->val + root2->val);
+    node->left = mergeTrees(root1->left, root2->left);
+    node->right = mergeTrees(root1->right, root2->right);
+    return node;
+  }
+};