103. Binary Tree Zigzag Level Order Traversal

103/step1.cpp

@@ -0,0 +1,37 @@
+/*
+
+Solve Time : 11:48
+
+Time : O(N)
+Space : O(N)
+*/
+class Solution {
+ public:
+  vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+    bool reversed_level = false;
+    vector<vector<int>> zigzag_level_ordered_vals;
+    vector<TreeNode*> current_level_nodes = {root};
+    while (!current_level_nodes.empty()) {
+      vector<TreeNode*> next_level_nodes;
+      vector<int> same_level_vals;
+      for (int i = 0; i < current_level_nodes.size(); ++i) {
+        if (!current_level_nodes[i]) {
+          continue;
+        }
+        same_level_vals.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_vals.empty()) {
+        break;
+      }
+      if (reversed_level) {
+        reverse(same_level_vals.begin(), same_level_vals.end());
+      }
+      reversed_level = !reversed_level;
+      swap(current_level_nodes, next_level_nodes);
+      zigzag_level_ordered_vals.push_back(same_level_vals);
+    }
+    return zigzag_level_ordered_vals;
+  }
+};

103/step2.cpp

@@ -0,0 +1,40 @@
+/*
+Time: O(N)
+Space: O(N)
+
+nil判定を最初に置くことでwhileの条件やbreakを素直にした
+*/
+class Solution {
+  public:
+   vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+     if (!root) {
+       return {};
+     }
+     bool reversed_level = false;
+     vector<vector<int>> zigzag_level_ordered_vals;
+     vector<TreeNode*> current_level_nodes = {root};
+     while (!current_level_nodes.empty()) {
+       vector<TreeNode*> next_level_nodes;
+       vector<int> same_level_vals;
+       for (int i = 0; i < current_level_nodes.size(); ++i) {
+         if (!current_level_nodes[i]) {
+           continue;
+         }
+         same_level_vals.push_back(current_level_nodes[i]->val);
+         if (current_level_nodes[i]->left) {
+           next_level_nodes.push_back(current_level_nodes[i]->left);
+         }
+         if (current_level_nodes[i]->right) {
+           next_level_nodes.push_back(current_level_nodes[i]->right);
+         }
+       }
+       if (reversed_level) {
+         reverse(same_level_vals.begin(), same_level_vals.end());
+       }
+       reversed_level = !reversed_level;
+       swap(current_level_nodes, next_level_nodes);
+       zigzag_level_ordered_vals.push_back(same_level_vals);
+     }
+     return zigzag_level_ordered_vals;
+   }
+ };

103/step3.cpp

@@ -0,0 +1,32 @@
+class Solution {
+  public:
+   vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+     if (!root) {
+       return {};
+     }
+     bool reverse_level = false;
+     vector<vector<int>> level_ordered_vals;
+     vector<TreeNode*> current_level_nodes = {root};
+     while (!current_level_nodes.empty()) {
+       vector<TreeNode*> next_level_nodes;
+       level_ordered_vals.push_back({});
+       for (int i = 0; i < current_level_nodes.size(); ++i) {
+         auto node = current_level_nodes[i];
+         if (node->left) {
+           next_level_nodes.push_back(node->left);
+         }
+         if (node->right) {
+           next_level_nodes.push_back(node->right);
+         }
+         level_ordered_vals.back().push_back(node->val);
+       }
+       if (reverse_level) {
+         reverse(level_ordered_vals.back().begin(), level_ordered_vals.back().end());
+       }
+       reverse_level = !reverse_level;
+       swap(next_level_nodes, current_level_nodes);
+     }
+     return level_ordered_vals;
+   }
+ };
+