From 1d629738e270b7b3395732aa65aa22e9f0174f63 Mon Sep 17 00:00:00 2001
From: colorbox <colorbox222@gmail.com>
Date: Wed, 19 Feb 2025 01:53:10 +0900
Subject: [PATCH] 102. Binary Tree Level Order Traversal
---
102/step1.cpp | 36 ++++++++++++++++++++++++++++++++++++
102/step2_1.cpp | 37 +++++++++++++++++++++++++++++++++++++
102/step2_2.cpp | 25 +++++++++++++++++++++++++
102/step3.cpp | 22 ++++++++++++++++++++++
4 files changed, 120 insertions(+)
create mode 100644 102/step1.cpp
create mode 100644 102/step2_1.cpp
create mode 100644 102/step2_2.cpp
create mode 100644 102/step3.cpp
diff --git a/102/step1.cpp b/102/step1.cpp
new file mode 100644
index 0000000..9a3eef3
--- /dev/null
+++ b/102/step1.cpp
@@ -0,0 +1,36 @@
+/*
+Solve Time: 21:38
+
+Time : O(N^2)
+Space : O(N^2)
+*/
+class Solution {
+ public:
+ vector<vector<int>> levelOrder(TreeNode* root) {
+ if (!root) {
+ return {};
+ }
+ auto left = levelOrder(root->left);
+ auto right = levelOrder(root->right);
+ auto merged_level_vals = merge_two_trees(left, right);
+ vector<vector<int>> level_order = {{root->val}};
+ level_order.insert(level_order.end(), merged_level_vals.begin(), merged_level_vals.end());
+ return level_order;
+ }
+
+ private:
+ vector<vector<int>> merge_two_trees(vector<vector<int>>& left, vector<vector<int>>& right) {
+ vector<vector<int>> merged_levels;
+ for (int i = 0; i < max(left.size(), right.size()); ++i) {
+ vector<int> current_level_vals;
+ if (i < left.size()) {
+ current_level_vals.insert(current_level_vals.end(), left[i].begin(), left[i].end());
+ }
+ if (i < right.size()) {
+ current_level_vals.insert(current_level_vals.end(), right[i].begin(), right[i].end());
+ }
+ merged_levels.push_back(current_level_vals);
+ }
+ return merged_levels;
+ }
+};
diff --git a/102/step2_1.cpp b/102/step2_1.cpp
new file mode 100644
index 0000000..ead29ff
--- /dev/null
+++ b/102/step2_1.cpp
@@ -0,0 +1,37 @@
+/*
+Time : O(N)
+Space : O(N)
+
+再帰を用いずに書いてみる。
+currentはnextとの対比として自然なので使用した。
+XXX_level_nodesはちょっと変数名がくどすぎる気もしたが、今見ているlevelというのを強調できるのでcurrent_nodesなどよりも適切に感じる。
+
+*/
+class Solution {
+ public:
+ vector<vector<int>> levelOrder(TreeNode* root) {
+ vector<vector<int>> level_order;
+ queue<TreeNode*> current_level_nodes;
+ queue<TreeNode*> next_level_nodes;
+ current_level_nodes.push(root);
+ while (true) {
+ vector<int> same_level_vals;
+ while (!current_level_nodes.empty()) {
+ auto node = current_level_nodes.front();
+ current_level_nodes.pop();
+ if (!node) {
+ continue;
+ }
+ same_level_vals.push_back(node->val);
+ next_level_nodes.push(node->left);
+ next_level_nodes.push(node->right);
+ }
+ swap(current_level_nodes, next_level_nodes);
+ if (same_level_vals.empty()) {
+ break;
+ }
+ level_order.push_back(same_level_vals);
+ }
+ return level_order;
+ }
+};
diff --git a/102/step2_2.cpp b/102/step2_2.cpp
new file mode 100644
index 0000000..750eb96
--- /dev/null
+++ b/102/step2_2.cpp
@@ -0,0 +1,25 @@
+class Solution {
+ public:
+ vector<vector<int>> levelOrder(TreeNode* root) {
+ vector<vector<int>> level_ordered_nums;
+ vector<TreeNode*> current_level_nodes = {root};
+ while (!current_level_nodes.empty()) {
+ vector<TreeNode*> next_level_nodes;
+ vector<int> same_level_nums;
+ for (int i = 0; i < current_level_nodes.size(); ++i) {
+ if (!current_level_nodes[i]) {
+ continue;
+ }
+ same_level_nums.push_back(current_level_nodes[i]->val);
+ next_level_nodes.push_back(current_level_nodes[i]->left);
+ next_level_nodes.push_back(current_level_nodes[i]->right);
+ }
+ if (same_level_nums.empty()) {
+ break;
+ }
+ level_ordered_nums.push_back(same_level_nums);
+ swap(current_level_nodes, next_level_nodes);
+ }
+ return level_ordered_nums;
+ }
+};
diff --git a/102/step3.cpp b/102/step3.cpp
new file mode 100644
index 0000000..b443335
--- /dev/null
+++ b/102/step3.cpp
@@ -0,0 +1,22 @@
+class Solution {
+ public:
+ vector<vector<int>> levelOrder(TreeNode* root) {
+ if (!root) {
+ return {};
+ }
+ vector<vector<int>> level_order = {{root->val}};
+ auto left_level_order = levelOrder(root->left);
+ auto right_level_order = levelOrder(root->right);
+ for (int i = 0; i < max(left_level_order.size(), right_level_order.size()); ++i) {
+ vector<int> same_level_values;
+ if (i < left_level_order.size()) {
+ same_level_values.insert(same_level_values.end(), left_level_order[i].begin(), left_level_order[i].end());
+ }
+ if (i < right_level_order.size()) {
+ same_level_values.insert(same_level_values.end(), right_level_order[i].begin(), right_level_order[i].end());
+ }
+ level_order.push_back(same_level_values);
+ }
+ return level_order;
+ }
+};