algorithm-archivists
diff --git a/Diff for: ‎contents/tree_traversal/code/c++/tree_example.cpp
+19-14 b/Diff for: ‎contents/tree_traversal/code/c++/tree_example.cpp
+19-14
diff --git a/Diff for: ‎contents/tree_traversal/code/c/tree_traversal.c
+30-8 b/Diff for: ‎contents/tree_traversal/code/c/tree_traversal.c
+30-8
diff --git a/Diff for: ‎contents/tree_traversal/code/clisp/tree-traversal.lisp
+12-7 b/Diff for: ‎contents/tree_traversal/code/clisp/tree-traversal.lisp
+12-7
diff --git a/Diff for: ‎contents/tree_traversal/code/coconut/tree_traversal.coco
+8-13 b/Diff for: ‎contents/tree_traversal/code/coconut/tree_traversal.coco
+8-13
diff --git a/Diff for: ‎contents/tree_traversal/code/crystal/tree-traversal.cr
+12-38 b/Diff for: ‎contents/tree_traversal/code/crystal/tree-traversal.cr
+12-38
@@ -17,7 +17,7 @@ struct node {
 // Simple recursive scheme for DFS
 void dfs_recursive(node const& n) {
   // Here we are doing something...
-  std::cout << n.value << '\n';
+  std::cout << n.value << ' ';
   for (auto const& child : n.children) {
     dfs_recursive(child);
   }
@@ -27,23 +27,23 @@ void dfs_recursive_postorder(node const& n) {
   for (auto const& child : n.children) {
     dfs_recursive_postorder(child);
   }
-  std::cout << n.value << '\n';
+  std::cout << n.value << ' ';
 }
 
 
 void dfs_recursive_inorder_btree(node const& n) {
   switch (n.children.size()) {
     case 2:
       dfs_recursive_inorder_btree(n.children[0]);
-      std::cout << n.value << '\n';
+      std::cout << n.value << ' ';
       dfs_recursive_inorder_btree(n.children[1]);
       break;
     case 1:
       dfs_recursive_inorder_btree(n.children[0]);
-      std::cout << n.value << '\n';
+      std::cout << n.value << ' ';
       break;
     case 0:
-      std::cout << n.value << '\n';
+      std::cout << n.value << ' ';
       break;
     default:
       std::cout << "This is not a binary tree.\n";
@@ -61,7 +61,7 @@ void dfs_stack(node const& n) {
   while (stack.size() > 0) {
     auto const& temp = *stack.top();
     stack.pop();
-    std::cout << temp.value << '\n';
+    std::cout << temp.value << ' ';
 
     for (auto const& child : temp.children) {
       stack.push(&child);
@@ -78,7 +78,7 @@ void bfs_queue(node const& n) {
     auto const& temp = *queue.front();
     queue.pop();
 
-    std::cout << temp.value << '\n';
+    std::cout << temp.value << ' ';
     for (auto const& child : temp.children) {
       queue.push(&child);
     }
@@ -100,18 +100,23 @@ node create_tree(size_t num_row, size_t num_child) {
 
 int main() {
   // Creating Tree in main
-  auto root = create_tree(3, 3);
+  auto root = create_tree(2, 3);
   auto binary_root = create_tree(3, 2);
-  std::cout << "DFS recursive:\n";
+  std::cout << "[#]\nRecursive DFS:\n";
   dfs_recursive(root);
-  std::cout << "DFS post order recursive:\n";
+  std::cout << '\n';
+  std::cout << "[#]\nRecursive Postorder DFS:\n";
   dfs_recursive_postorder(root);
-  std::cout << "DFS inorder binary tree:\n";
-  dfs_recursive_inorder_btree(binary_root);
-  std::cout << "DFS stack:\n";
+  std::cout << '\n';
+  std::cout << "[#]\nStack-based DFS:\n";
   dfs_stack(root);
-  std::cout << "BFS queue:\n";
+  std::cout << '\n';
+  std::cout << "[#]\nQueue-based BFS:\n";
   bfs_queue(root);
+  std::cout << '\n';
+  std::cout << "[#]\nRecursive Inorder DFS for Binary Tree:\n";
+  dfs_recursive_inorder_btree(binary_root);
+  std::cout << '\n';
 
   return 0;
 }
@@ -35,7 +35,7 @@ void destroy_tree(struct node n) {
 }
 
 void dfs_recursive(struct node n) {
-    printf("%d\n", n.id);
+    printf("%d ", n.id);
 
     if (n.children) {
         for (size_t i = 0; i < n.children_size; ++i) {
@@ -49,22 +49,22 @@ void dfs_recursive_postorder(struct node n) {
         dfs_recursive_postorder(n.children[i]);
     }
 
-    printf("%d\n", n.id);
+    printf("%d ", n.id);
 }
 
 void dfs_recursive_inorder_btree(struct node n) {
     switch (n.children_size) {
     case 2:
         dfs_recursive_inorder_btree(n.children[0]);
-        printf("%d\n", n.id);
+        printf("%d ", n.id);
         dfs_recursive_inorder_btree(n.children[1]);
         break;
     case 1:
         dfs_recursive_inorder_btree(n.children[0]);
-        printf("%d\n", n.id);
+        printf("%d ", n.id);
         break;
     case 0:
-        printf("%d\n", n.id);
+        printf("%d ", n.id);
         break;
     default:
         printf("This is not a binary tree.\n");
@@ -83,7 +83,7 @@ void dfs_stack(struct node n) {
             break;
         }
 
-        printf("%d\n", tmp->id);
+        printf("%d ", tmp->id);
         for (size_t i = 0; i < tmp->children_size; ++i) {
             stack_push(&stk, &tmp->children[i]);
         }
@@ -103,7 +103,7 @@ void bfs_queue(struct node n) {
             break;
         }
 
-        printf("%d\n", tmp->id);
+        printf("%d ", tmp->id);
         for (size_t i = 0; i < tmp->children_size; ++i) {
             enqueue(&q, &tmp->children[i]);
         }
@@ -113,9 +113,31 @@ void bfs_queue(struct node n) {
 }
 
 int main() {
-    struct node root = create_tree(3, 3);
+    struct node root = create_tree(2, 3);
+
+    printf("[#]\nRecursive DFS:\n");
+    dfs_recursive(root);
+    printf("\n");
+    
+    printf("[#]\nRecursive Postorder DFS:\n");
+    dfs_recursive_postorder(root);
+    printf("\n");
+    
+    printf("[#]\nStack-based DFS:\n");
+    dfs_stack(root);
+    printf("\n");
+    
+    printf("[#]\nQueue-based BFS:\n");
     bfs_queue(root);
+    printf("\n");
+    
     destroy_tree(root);
+    struct node root_binary = create_tree(3, 2);
 
+    printf("[#]\nRecursive Inorder DFS for Binary Tree:\n");
+    dfs_recursive_inorder_btree(root_binary);
+    printf("\n");
+    
+    destroy_tree(root_binary);
     return 0;
 }
@@ -58,36 +58,41 @@
 (defun make-tree (num-rows num-child)
   "Creates a simple tree, where every node has 'num-child' children and is 'num-rows' deep."
   ;; A tree with 0 rows can't be created.
-  (if (eql num-rows 1)
+  (if (eql num-rows 0)
       (make-node
-       :data 1
+       :data 0
        :children nil)
       (make-node
        :data num-rows
        :children (loop repeat num-child collect (make-tree (1- num-rows) num-child)))))
 
 ;; A tree for testing
-(defvar tree (make-tree 3 3))
+(defvar tree (make-tree 2 3))
 
 ;; A binary tree for testing
 (defvar binary-tree (make-tree 3 2))
 
 ;; Should print: 3 2 1 1 1 2 1 1 1 2 1 1 1
+(format t "[#]~%Recursive DFS:~%")
 (dfs-recursive tree)
 (format t "~%")
 
 ;; Should print: 1 1 1 2 1 1 1 2 1 1 1 2 3
+(format t "[#]~%Recursive Postorder DFS:~%")
 (dfs-recursive-postorder tree)
 (format t "~%")
 
-;; Should print: 1 2 1 3 1 2 1
-(dfs-recursive-inorder-btree binary-tree)
-(format t "~%")
-
 ;; Should print: 3 2 1 1 1 2 1 1 1 2 1 1 1
+(format t "[#]~%Stack-based DFS:~%")
 (dfs-stack tree)
 (format t "~%")
 
 ;; Should print: 3 2 2 2 1 1 1 1 1 1 1 1 1
+(format t "[#]~%Queue-based BFS:~%")
 (bfs-queue tree)
 (format t "~%")
+
+;; Should print: 1 2 1 3 1 2 1
+(format t "[#]~%Recursive Inorder DFS for Binary Tree:~%")
+(dfs-recursive-inorder-btree binary-tree)
+(format t "~%")
@@ -50,42 +50,37 @@ def bfs_queue(node is Node):
 def create_tree(num_rows, num_child):
     """Creates a simple tree, where every node has
     'num_child' children and is 'num_rows' deep."""
-    if num_rows == 1:
-        return Node(1, ())
+    if num_rows == 0:
+        return Node(0, ())
     else:
         return Node(num_rows, tuple(create_tree(num_rows-1, num_child)
                                     for _ in range(num_child)))
 
 
 if __name__ =='__main__':
     # A ternary tree for testing
-    tree = create_tree(3, 3)
+    tree = create_tree(2, 3)
 
-    # Should print: 3 2 1 1 1 2 1 1 1 2 1 1 1
-    print("Recursive DFS:")
+    print("[#]\nRecursive DFS:")
     dfs_recursive(tree)
     print()
 
-    # Should print: 1 1 1 2 1 1 1 2 1 1 1 2 3
-    print("Recursive Postorder DFS:")
+    print("[#]\nRecursive Postorder DFS:")
     dfs_recursive_postorder(tree)
     print()
 
-    # Should print: 3 2 1 1 1 2 1 1 1 2 1 1 1
-    print("Stack (DFS):")
+    print("[#]\nStack-based DFS:")
     dfs_stack(tree)
     print()
 
-    # Should print: 3 2 2 2 1 1 1 1 1 1 1 1 1
-    print("Queue (BFS):")
+    print("[#]\nQueue-based BFS:")
     bfs_queue(tree)
     print()
 
     # And a binary tree for testing
     binary_tree = create_tree(3, 2)
 
-    # Should print: 1 2 1 3 1 2 1
-    print("Recursive Inorder Binary Tree:")
+    print("[#]\nRecursive Inorder DFS for Binary Tree:")
     dfs_recursive_inorder_btree(binary_tree)
     print()
 
@@ -5,26 +5,26 @@ class Node
 end 
 
 def dfs_recursive(node) 
-  print node.id
+  print "#{node.id} "
   node.children.each{ |child| dfs_recursive child } 
 end
 
 def dfs_recursive_postorder(node) 
   node.children.each{ |child| dfs_recursive_postorder child }
-  print node.id 
+  print "#{node.id} "
 end 
 
 def dfs_recursive_inorder_btree(node) 
   case node.children.size
   when 2
     dfs_recursive_inorder_btree node.children[0]
-    print node.id 
+    print "#{node.id} "
     dfs_recursive_inorder_btree node.children[1]  
   when 1 
     dfs_recursive_inorder_btree node.children[0]
-    print node.id 
+    print "#{node.id} "
   when 0 
-    print node.id 
+    print "#{node.id} "
   else 
     print "Not a binary tree!"
   end 
@@ -35,7 +35,7 @@ def dfs_stack(node)
 
   until stack.empty? 
     temp = stack.pop 
-    print temp.id
+    print "#{temp.id} "
     temp.children.each{ |child| stack.push child } 
   end 
 end 
@@ -45,7 +45,7 @@ def bfs_queue(node)
 
   until queue.empty? 
     temp = queue.shift
-    print temp.id 
+    print "#{temp.id} "
     temp.children.each{ |child| queue.push child }
   end  
 end 
@@ -60,54 +60,28 @@ def create_tree(levels, num_childs)
   Node.new(levels, children) 
 end
 
-def print_tree(node, depth = [] of String) 
-  puts "(#{node.id})"
-  depth.push " " 
-  len = node.children.size - 1
-
-  (0 .. len).each do |i|
-    depth.each{|c| print c} 
-    unless i == len 
-      print "├" 
-      depth.push "│"
-      print_tree node.children[i], depth
-      depth.pop 
-    else 
-      print "└"
-      depth.push " " 
-      print_tree node.children[i], depth
-      depth.pop
-    end 
-  end 
-  depth.pop 
-end 
-
 def main 
-  puts "Creating Tree" 
   root = create_tree levels: 2, num_childs: 3
-  print_tree root 
 
-  puts "Using recursive DFS:"
+  puts "[#]\nRecursive DFS:"
   dfs_recursive root
   puts  
 
-  puts "Using recursive DFS with post-order traversal:" 
+  puts "[#]\nRecursive Postorder DFS:" 
   dfs_recursive_postorder root 
   puts  
 
-  puts "Using stack-based DFS:"
+  puts "[#]\nStack-based DFS:"
   dfs_stack root 
   puts  
 
-  puts "Using queue-based BFS:"
+  puts "[#]\nQueue-based BFS:"
   bfs_queue root 
   puts  
 
-  puts "Creating binary tree to test in-order traversal"
   root_bin = create_tree levels: 3, num_childs: 2
-  print_tree root_bin 
 
-  puts "Using In-order DFS:"
+  puts "[#]\nRecursive Inorder DFS for Binary Tree:"
   dfs_recursive_inorder_btree root_bin
   puts
 end