day 20: 103-binary-tree-zigzag-level-order-traversal

103-binary-tree-zigzag-level-order-traversal/driver.cpp

@@ -0,0 +1,14 @@
+#include "soln.hpp"
+
+int main()
+{
+	TreeNode n7 = TreeNode(7);
+	TreeNode n15 = TreeNode(15);
+	TreeNode n20 = TreeNode(20, &n15, &n7);
+	TreeNode n9 = TreeNode(9);
+	TreeNode n3 = TreeNode(3, &n9, &n20);
+	vector<vector<int>> answer = {{3}, {20, 9}, {15, 7}};
+	Solution soln;
+	cout << "Zigzag level-order traversal correct? " << soln.test(&n3, answer) << endl;
+	return 0;
+}

103-binary-tree-zigzag-level-order-traversal/soln.cpp

@@ -0,0 +1,37 @@
+#include "soln.hpp"
+
+vector<vector<int>> Solution::zigzagLevelOrder(TreeNode *root)
+{
+	vector<vector<int>> result;
+	if (!root)
+		return result;
+	vector<TreeNode *> que{root};
+	bool rtl = false;
+	for (int level = 0; que.size() > 0; level++)
+	{
+		int prev_level_size = que.size();
+		result.push_back(vector<int>(0));
+		for (int i = 0; i < prev_level_size; i++)
+		{
+			if (que[i]->left)
+				que.push_back(que[i]->left);
+			if (que[i]->right)
+				que.push_back(que[i]->right);
+		}
+		for (int i = 0; i < prev_level_size; i++)
+		{
+			if (rtl)
+				result[level].push_back(que[prev_level_size - i - 1]->val);
+			else
+				result[level].push_back(que[i]->val);
+		}
+		que.erase(que.begin(), que.begin() + prev_level_size);
+		rtl = !rtl;
+	}
+	return result;
+}
+
+bool Solution::test(TreeNode *root, vector<vector<int>> answer)
+{
+	return zigzagLevelOrder(root) == answer;
+}

103-binary-tree-zigzag-level-order-traversal/soln.hpp

@@ -0,0 +1,19 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+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>> zigzagLevelOrder(TreeNode *root);
+	bool test(TreeNode *root, vector<vector<int>> answer);
+};