Added Tree traversal in Crystal-lang (#339)

* Added Tree Traversal in Crystal

Author: NIFR91

CONTRIBUTORS.md

@@ -61,4 +61,3 @@ Bendik Samseth
 Trashtalk
 <br>
 Cyrus Burt
-

contents/tree_traversal/code/crystal/tree-traversal.cr

@@ -0,0 +1,116 @@
+class Node 
+  property id, children 
+  def initialize(@id : Int32, @children : Array(Node))
+  end 
+end 
+
+def dfs_recursive(node) 
+  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 
+end 
+
+def dfs_recursive_inorder_btree(node) 
+  case node.children.size
+  when 2
+    dfs_recursive_inorder_btree node.children[0]
+    print node.id 
+    dfs_recursive_inorder_btree node.children[1]  
+  when 1 
+    dfs_recursive_inorder_btree node.children[0]
+    print node.id 
+  when 0 
+    print node.id 
+  else 
+    print "Not a binary tree!"
+  end 
+end 
+
+def dfs_stack(node) 
+  stack = [node] 
+
+  until stack.empty? 
+    temp = stack.pop 
+    print temp.id
+    temp.children.each{ |child| stack.push child } 
+  end 
+end 
+
+def bfs_queue(node) 
+  queue = Deque.new [node]
+
+  until queue.empty? 
+    temp = queue.shift
+    print temp.id 
+    temp.children.each{ |child| queue.push child }
+  end  
+end 
+
+def create_tree(levels, num_childs) 
+
+  children = [] of Node  
+  unless levels == 0 
+    num_childs.times{children.push create_tree levels-1, num_childs } 
+  end 
+  
+  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:"
+  dfs_recursive root
+  puts  
+
+  puts "Using recursive DFS with post-order traversal:" 
+  dfs_recursive_postorder root 
+  puts  
+
+  puts "Using stack-based DFS:"
+  dfs_stack root 
+  puts  
+
+  puts "Using queue-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:"
+  dfs_recursive_inorder_btree root_bin
+  puts
+end 
+
+main
+

contents/tree_traversal/tree_traversal.md

@@ -30,6 +30,8 @@ This has not been implemented in your chosen language, so here is the Julia code
 [import:1-9, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import:3-27, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import:1-5, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}
 
 Because of this, the most straightforward way to traverse the tree might be recursive. This naturally leads us to the Depth-First Search (DFS) method:
@@ -62,6 +64,8 @@ Because of this, the most straightforward way to traverse the tree might be recu
 [import:24-30, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import:31-35, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import:7-10, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}
 
 At least to me, this makes a lot of sense. We fight recursion with recursion! First, we first output the node we are on and then we call `DFS_recursive(...)` on each of its children nodes. This method of tree traversal does what its name implies: it goes to the depths of the tree first before going through the rest of the branches. In this case, the ordering looks like:
@@ -102,6 +106,8 @@ Now, in this case the first element searched through is still the root of the tr
 [import:32-38, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import:37-41, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import:12-15, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}
 
 <p>
@@ -137,6 +143,8 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 [import:40-53, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import:43-62, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import:17-31, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}
 
 <p>
@@ -183,6 +191,8 @@ This has not been implemented in your chosen language, so here is the Julia code
 [import:55-67, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import:64-73, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import:33-41, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}
 
 All this said, there are a few details about DFS that might not be idea, depending on the situation. For example, if we use DFS on an incredibly long tree, we will spend a lot of time going further and further down a single branch without searching the rest of the data structure. In addition, it is not the natural way humans would order a tree if asked to number all the nodes from top to bottom. I would argue a more natural traversal order would look something like this:
@@ -220,6 +230,8 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 [import:69-81, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import:65-74, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import:43-51, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}
 
 ## Example Code
@@ -259,6 +271,8 @@ The code snippets were taken from this [Scratch project](https://scratch.mit.edu
 [import, lang:"swift"](code/swift/tree.swift)
 {% sample lang="php"%}
 [import, lang:"php"](code/php/tree_traversal.php)
+{% sample lang="crystal" %}
+[import, lang:"crystal"](code/crystal/tree-traversal.cr)
 {% endmethod %}