3 files changed, 87 insertions, 0 deletions

diff --git a/src/02/01/binary_tree.c b/src/02/01/binary_tree.c
index af0d2b0..7fd9763 100644
--- a/src/02/01/binary_tree.c
+++ b/src/02/01/binary_tree.c
@@ -18,6 +18,15 @@ void preorder_traversal(Node *node, Visitor visitor) {
   preorder_traversal(node->right, visitor);
 }
 
+void postorder_traversal(Node *node, Visitor visitor) {
+  if (!node)
+    return;
+
+  postorder_traversal(node->left, visitor);
+  postorder_traversal(node->right, visitor);
+  visitor(node);
+}
+
 void destroy(Node *head) {
   free(head);
 }
diff --git a/src/02/01/binary_tree.h b/src/02/01/binary_tree.h
index 12df9d7..3b22eb3 100644
--- a/src/02/01/binary_tree.h
+++ b/src/02/01/binary_tree.h
@@ -9,4 +9,5 @@ typedef void(Visitor)(Node* node);
 
 Node *initialize(int data);
 void preorder_traversal(Node *node, Visitor visitor);
+void postorder_traversal(Node *node, Visitor visitor);
 void destroy(Node *head);
diff --git a/src/02/01/binary_tree_test.c b/src/02/01/binary_tree_test.c
index f20ecfe..68615e9 100644
--- a/src/02/01/binary_tree_test.c
+++ b/src/02/01/binary_tree_test.c
@@ -85,6 +85,74 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_multiple_levels
   assert_that(visited[4], is_equal_to(300));
 }
 
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty) {
+  postorder_traversal(NULL, visitor);
+
+  assert_that(visited_count, is_equal_to(0));
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_single_node) {
+  Node *node = initialize(100);
+
+  postorder_traversal(node, visitor);
+
+  assert_that(visited_count, is_equal_to(1));
+  assert_that(visited[0], is_equal_to(100));
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+
+  postorder_traversal(node, visitor);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(200));
+  assert_that(visited[1], is_equal_to(100));
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_right_node) {
+  Node *node = initialize(100);
+  node->right = initialize(300);
+
+  postorder_traversal(node, visitor);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(300));
+  assert_that(visited[1], is_equal_to(100));
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  postorder_traversal(node, visitor);
+
+  assert_that(visited_count, is_equal_to(3));
+  assert_that(visited[0], is_equal_to(200));
+  assert_that(visited[1], is_equal_to(300));
+  assert_that(visited[2], is_equal_to(100));
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_multiple_levels) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  node->left->left = initialize(400);
+  node->left->right = initialize(500);
+
+  postorder_traversal(node, visitor);
+
+  assert_that(visited_count, is_equal_to(5));
+  assert_that(visited[0], is_equal_to(400));
+  assert_that(visited[1], is_equal_to(500));
+  assert_that(visited[2], is_equal_to(200));
+  assert_that(visited[3], is_equal_to(300));
+  assert_that(visited[4], is_equal_to(100));
+}
+
 TestSuite *binary_tree_tests() {
   TestSuite *suite = create_test_suite();
 
@@ -92,6 +160,15 @@ TestSuite *binary_tree_tests() {
   add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_single_node);
   add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_node);
   add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_right_node);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_multiple_levels);
+
+  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_single_node);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_node);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_right_node);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_multiple_levels);
 
   return suite;
 }