Delegate to the single traverse function

3 files changed, 42 insertions, 44 deletions

diff --git a/src/02/01/binary_tree.c b/src/02/01/binary_tree.c
index 7cdd197..24bdccd 100644
--- a/src/02/01/binary_tree.c
+++ b/src/02/01/binary_tree.c
@@ -9,31 +9,30 @@ Node *initialize(int data) {
   return item;
 }
 
-void preorder_traversal(Node *node, Visitor visitor) {
+void traverse(Node *node, Visitor visitor, enum Traversal traversal) {
   if (!node)
     return;
 
-  visitor(node);
-  preorder_traversal(node->left, visitor);
-  preorder_traversal(node->right, visitor);
-}
-
-void inorder_traversal(Node *node, Visitor visitor) {
-  if (!node)
-    return;
-
-  inorder_traversal(node->left, visitor);
-  visitor(node);
-  inorder_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);
+  switch (traversal) {
+    case PREORDER:
+      visitor(node);
+      traverse(node->left, visitor, traversal);
+      traverse(node->right, visitor, traversal);
+      break;
+    case INORDER:
+      traverse(node->left, visitor, traversal);
+      visitor(node);
+      traverse(node->right, visitor, traversal);
+      break;
+    case POSTORDER:
+      traverse(node->left, visitor, traversal);
+      traverse(node->right, visitor, traversal);
+      visitor(node);
+      break;
+    default:
+      visitor(node);
+      break;
+  }
 }
 
 static void destructor(Node *node) {
@@ -41,5 +40,5 @@ static void destructor(Node *node) {
 }
 
 void destroy(Node *head) {
-  postorder_traversal(head, destructor);
+  traverse(head, destructor, POSTORDER);
 }
diff --git a/src/02/01/binary_tree.h b/src/02/01/binary_tree.h
index a8d5fb8..93a6f12 100644
--- a/src/02/01/binary_tree.h
+++ b/src/02/01/binary_tree.h
@@ -6,9 +6,8 @@ struct node {
 
 typedef struct node Node;
 typedef void(Visitor)(Node* node);
+enum Traversal { INORDER = 1, PREORDER = 2, POSTORDER = 4 };
 
 Node *initialize(int data);
-void preorder_traversal(Node *node, Visitor visitor);
-void inorder_traversal(Node *node, Visitor visitor);
-void postorder_traversal(Node *node, Visitor visitor);
+void traverse(Node *node, Visitor visitor, enum Traversal traversal);
 void destroy(Node *head);
diff --git a/src/02/01/binary_tree_test.c b/src/02/01/binary_tree_test.c
index 4804d76..7f26479 100644
--- a/src/02/01/binary_tree_test.c
+++ b/src/02/01/binary_tree_test.c
@@ -18,7 +18,7 @@ void visitor(Node *node) {
 }
 
 Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_is_empty) {
-  preorder_traversal(NULL, visitor);
+  traverse(NULL, visitor, PREORDER);
 
   assert_that(visited_count, is_equal_to(0));
 }
@@ -26,7 +26,7 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_is_empty) {
 Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_single_node) {
   Node *node = initialize(100);
 
-  preorder_traversal(node, visitor);
+  traverse(node, visitor, PREORDER);
 
   assert_that(visited_count, is_equal_to(1));
   assert_that(visited[0], is_equal_to(100));
@@ -37,7 +37,7 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_node) {
   Node *node = initialize(100);
   node->left = initialize(200);
 
-  preorder_traversal(node, visitor);
+  traverse(node, visitor, PREORDER);
 
   assert_that(visited_count, is_equal_to(2));
   assert_that(visited[0], is_equal_to(100));
@@ -49,7 +49,7 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_right_node) {
   Node *node = initialize(100);
   node->right = initialize(300);
 
-  preorder_traversal(node, visitor);
+  traverse(node, visitor, PREORDER);
 
   assert_that(visited_count, is_equal_to(2));
   assert_that(visited[0], is_equal_to(100));
@@ -62,7 +62,7 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_and_righ
   node->left = initialize(200);
   node->right = initialize(300);
 
-  preorder_traversal(node, visitor);
+  traverse(node, visitor, PREORDER);
 
   assert_that(visited_count, is_equal_to(3));
   assert_that(visited[0], is_equal_to(100));
@@ -79,7 +79,7 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_multiple_levels
   node->left->left = initialize(400);
   node->left->right = initialize(500);
 
-  preorder_traversal(node, visitor);
+  traverse(node, visitor, PREORDER);
 
   assert_that(visited_count, is_equal_to(5));
   assert_that(visited[0], is_equal_to(100));
@@ -91,7 +91,7 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_multiple_levels
 }
 
 Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty) {
-  postorder_traversal(NULL, visitor);
+  traverse(NULL, visitor, POSTORDER);
 
   assert_that(visited_count, is_equal_to(0));
 }
@@ -99,7 +99,7 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty) {
 Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_single_node) {
   Node *node = initialize(100);
 
-  postorder_traversal(node, visitor);
+  traverse(node, visitor, POSTORDER);
 
   assert_that(visited_count, is_equal_to(1));
   assert_that(visited[0], is_equal_to(100));
@@ -110,7 +110,7 @@ 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);
+  traverse(node, visitor, POSTORDER);
 
   assert_that(visited_count, is_equal_to(2));
   assert_that(visited[0], is_equal_to(200));
@@ -122,7 +122,7 @@ 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);
+  traverse(node, visitor, POSTORDER);
 
   assert_that(visited_count, is_equal_to(2));
   assert_that(visited[0], is_equal_to(300));
@@ -135,7 +135,7 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_and_rig
   node->left = initialize(200);
   node->right = initialize(300);
 
-  postorder_traversal(node, visitor);
+  traverse(node, visitor, POSTORDER);
 
   assert_that(visited_count, is_equal_to(3));
   assert_that(visited[0], is_equal_to(200));
@@ -152,7 +152,7 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_multiple_level
   node->left->left = initialize(400);
   node->left->right = initialize(500);
 
-  postorder_traversal(node, visitor);
+  traverse(node, visitor, POSTORDER);
 
   assert_that(visited_count, is_equal_to(5));
   assert_that(visited[0], is_equal_to(400));
@@ -164,7 +164,7 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_multiple_level
 }
 
 Ensure(BinaryTree, when_traversing_inorder_when_the_tree_is_empty) {
-  inorder_traversal(NULL, visitor);
+  traverse(NULL, visitor, INORDER);
 
   assert_that(visited_count, is_equal_to(0));
 }
@@ -172,7 +172,7 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_is_empty) {
 Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_single_node) {
   Node *node = initialize(100);
 
-  inorder_traversal(node, visitor);
+  traverse(node, visitor, INORDER);
 
   assert_that(visited_count, is_equal_to(1));
   assert_that(visited[0], is_equal_to(100));
@@ -183,7 +183,7 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_left_node) {
   Node *node = initialize(100);
   node->left = initialize(200);
 
-  inorder_traversal(node, visitor);
+  traverse(node, visitor, INORDER);
 
   assert_that(visited_count, is_equal_to(2));
   assert_that(visited[0], is_equal_to(200));
@@ -195,7 +195,7 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_right_node) {
   Node *node = initialize(100);
   node->right = initialize(300);
 
-  inorder_traversal(node, visitor);
+  traverse(node, visitor, INORDER);
 
   assert_that(visited_count, is_equal_to(2));
   assert_that(visited[0], is_equal_to(100));
@@ -208,7 +208,7 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_left_and_right_no
   node->left = initialize(200);
   node->right = initialize(300);
 
-  inorder_traversal(node, visitor);
+  traverse(node, visitor, INORDER);
 
   assert_that(visited_count, is_equal_to(3));
   assert_that(visited[0], is_equal_to(200));
@@ -225,7 +225,7 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_multiple_levels) {
   node->left->left = initialize(400);
   node->left->right = initialize(500);
 
-  inorder_traversal(node, visitor);
+  traverse(node, visitor, INORDER);
 
   assert_that(visited_count, is_equal_to(5));
   assert_that(visited[0], is_equal_to(400));