102. Binary Tree Level Order Traversal

arai60/binary-tree-level-order-traversal/README.md

@@ -0,0 +1,34 @@
+## 考察
+- 過去に解いたことあり
+- 方針
+    - BFS
+        - BFSはlevelごとに見ていくのでシンプルに解ける
+        - 実装としては、キューを1つ使う方法と2つ使う方法が考えられる
+    - DFS
+        - 一応、levelを追跡すればOK
+        - でも、DFSでやるメリットはないと思われる
+- まずは、BFSのキューを1つだけ用意する方法で実装
+
+## Step1
+- BFSで実装
+- time: O(n), space: O(n)
+
+## Step2
+- キューを2つ用意する方法でも実装
+    - `step2_bfs_two_queues.cpp`
+- 特にキューである必要もないので、vector2つでも実装
+    - `step2_bfs_two_vectors.cpp`
+- 練習のためにDFSでも実装
+    - `stpe2_dfs.cpp`
+- 他の人のPRを検索
+    - https://github.com/fhiyo/leetcode/pull/28
+        - append_if_existsはいいなあと思った
+    - https://github.com/Mike0121/LeetCode/pull/7
+        - currentについて
+            - https://github.com/Mike0121/LeetCode/pull/7#discussion_r1587660995
+            - たしかに `level_values` だけでも通じるかも
+
+## Step3
+- 1回目: 3m27s
+- 2回目: 3m12s
+- 3回目: 3m05s

arai60/binary-tree-level-order-traversal/step1.cpp

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if (!root) return vector<vector<int>>();
+        vector<vector<int>> answer;
+        queue<TreeNode*> nodes_to_visit;
+        nodes_to_visit.push(root);
+        while (!nodes_to_visit.empty()) {
+            int level_size = nodes_to_visit.size();
+            vector<int> current_level_values;
+            for (int i = 0; i < level_size; i++) {
+                TreeNode* node = nodes_to_visit.front();
+                nodes_to_visit.pop();
+                current_level_values.push_back(node->val);
+                if (node->left) nodes_to_visit.push(node->left);
+                if (node->right) nodes_to_visit.push(node->right);
+            }
+            answer.push_back(move(current_level_values));
+        }
+        return answer;
+    }
+};

arai60/binary-tree-level-order-traversal/step2_bfs_two_queues.cpp

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if (!root) return vector<vector<int>>();
+        vector<vector<int>> answer;
+        queue<TreeNode*> nodes_to_visit;
+        nodes_to_visit.push(root);
+        while (!nodes_to_visit.empty()) {
+            vector<int> current_level_values;
+            queue<TreeNode*> next_level_nodes;
+            int level_size = nodes_to_visit.size();
+            for (int i = 0; i < level_size; i++) {
+                TreeNode* node = nodes_to_visit.front();
+                nodes_to_visit.pop();
+                current_level_values.push_back(node->val);
+                if (node->left) next_level_nodes.push(node->left);
+                if (node->right) next_level_nodes.push(node->right);
+            }
+            answer.push_back(move(current_level_values));
+            nodes_to_visit = next_level_nodes;
+        }
+        return answer;
+    }

arai60/binary-tree-level-order-traversal/step2_bfs_two_vectors.cpp

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if (!root) return vector<vector<int>>();
+        vector<vector<int>> answer;
+        vector<TreeNode*> nodes_to_visit;
+        nodes_to_visit.push_back(root);
+        while (!nodes_to_visit.empty()) {
+            vector<int> current_level_values;
+            vector<TreeNode*> next_level_nodes;
+            for (TreeNode* node : nodes_to_visit) {
+                current_level_values.push_back(node->val);
+                if (node->left) next_level_nodes.push_back(node->left);
+                if (node->right) next_level_nodes.push_back(node->right);
+            }
+            answer.push_back(move(current_level_values));
+            nodes_to_visit = next_level_nodes;
+        }
+        return answer;
+    }
+};

arai60/binary-tree-level-order-traversal/step2_dfs.cpp

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if (!root) return vector<vector<int>>();
+        vector<vector<int>> answer;
+        stack<pair<TreeNode*, int>> nodes_to_visit;
+        nodes_to_visit.push({root, 0});
+        while (!nodes_to_visit.empty()) {
+            auto [node, level] = nodes_to_visit.top();
+            nodes_to_visit.pop();
+            if (answer.size() == level) {
+                answer.push_back({node->val});
+            } else {
+                answer[level].push_back(node->val);;
+            }
+
+            if (node->right) nodes_to_visit.push({node->right, level + 1});
+            if (node->left) nodes_to_visit.push({node->left, level + 1});
+        }
+        return answer;
+    }
+};

arai60/binary-tree-level-order-traversal/step3.cpp

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if (!root) return {};
+        vector<vector<int>> answer;
+        queue<TreeNode*> nodes_to_visit;
+        nodes_to_visit.push(root);
+        while (!nodes_to_visit.empty()) {
+            int level_size = nodes_to_visit.size();
+            vector<int> level_values;
+            for (int i = 0; i < level_size; i++) {
+                auto node = nodes_to_visit.front();
+                nodes_to_visit.pop();
+                level_values.push_back(node->val);
+                if (node->left) nodes_to_visit.push(node->left);
+                if (node->right) nodes_to_visit.push(node->right);
+            }
+            answer.push_back(move(level_values));
+        }
+        return answer;
+    }
+};