Tree Traversal in Ruby

Author: tarunvelli

CONTRIBUTORS.md

@@ -48,3 +48,4 @@ This file lists everyone, who contributed to this repo and wanted to show up her
 - dovisutu
 - Antetokounpo
 - Akash Dhiman
+- Tarun Vellishetty

contents/tree_traversal/code/ruby/tree.rb

@@ -0,0 +1,54 @@
+def create_tree(rows, children)
+  return { id: rows, children: [] } if rows.zero?
+
+  {
+    id: rows,
+    children: Array.new(3, create_tree(rows - 1, children))
+  }
+end
+
+def dfs_preorder(tree)
+  puts tree[:id]
+  tree[:children].each { |child| dfs_preorder(child) }
+end
+
+def dfs_postorder(tree)
+  tree[:children].each { |child| dfs_postorder(child) }
+  puts tree[:id]
+end
+
+def dfs_inorder(tree)
+  return unless tree
+
+  if tree[:children].count > 2
+    raise 'Postorder traversal is only valid for binary trees'
+  end
+
+  dfs_inorder(tree.children[0])
+  puts tree[:id]
+  dfs_inorder(tree.children[1])
+end
+
+def dfs_iterative(tree)
+  stack = [tree]
+  while stack.count.positive?
+    current = stack.pop
+    puts current[:id]
+    stack.push(*current[:children])
+  end
+end
+
+def bfs(tree)
+  queue = [tree]
+  while queue.count.positive?
+    current = queue.shift
+    puts current[:id]
+    queue.push(*current[:children])
+  end
+end
+
+root = create_tree(3, 3)
+dfs_preorder(root)
+dfs_postorder(root)
+dfs_iterative(root)
+bfs(root)

contents/tree_traversal/tree_traversal.md

@@ -38,6 +38,8 @@ As a note, a `node` struct is not necessary in javascript, so this is an example
 [import:24-27, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import:1-3, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import:1-8, lang:"ruby"](code/ruby/tree.rb)
 {% 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:
@@ -78,6 +80,8 @@ Because of this, the most straightforward way to traverse the tree might be recu
 [import:290-314, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import:27-34, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import:10-13, lang:"ruby"](code/ruby/tree.rb)
 {% 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:
@@ -126,6 +130,8 @@ Now, in this case the first element searched through is still the root of the tr
 [import:316-344, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import:36-43, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import:15-18, lang:"ruby"](code/ruby/tree.rb)
 {% endmethod %}
 
 <p>
@@ -169,6 +175,8 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 [import:346-396, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import:45-62, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import:20-30, lang:"ruby"](code/ruby/tree.rb)
 {% endmethod %}
 
 <p>
@@ -222,6 +230,8 @@ In code, it looks like this:
 [import:398-445, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import:64-79, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import:32-39, lang:"ruby"](code/ruby/tree.rb)
 {% endmethod %}
 
 All this said, there are a few details about DFS that might not be ideal, 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:
@@ -267,6 +277,8 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 [import:447-498, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import:81-96, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import:41-48, lang:"ruby"](code/ruby/tree.rb)
 {% endmethod %}
 
 ## Video Explanation
@@ -322,6 +334,8 @@ The code snippets were taken from this [Scratch project](https://scratch.mit.edu
 [import, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
 {% sample lang="emojic" %}
 [import, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="ruby" %}
+[import, lang:"ruby"](code/ruby/tree.rb)
 {% endmethod %}