scala implementation of tree traversal

Author: Ken Power

contents/tree_traversal/code/scala/tree.scala

@@ -0,0 +1,107 @@
+import scala.collection.mutable._
+
+object TreeTraversal {
+
+  class Tree(val rowCount: Int, val childrenCount: Int) {
+
+    private case class Node(var id: Int) {
+
+      var children = ListBuffer[Node]()
+    }
+
+    private val root: Node = Node(1)
+    createAllChildren(root, rowCount, childrenCount)
+
+    private def createAllChildren(node: Node, rowCount: Int, childrenCount: Int): Unit = {
+      if (rowCount <= 1) return
+
+      0 until childrenCount foreach { i =>
+        node.children += Node(node.id * 10 + i + 1)
+        createAllChildren(node.children(i), rowCount - 1, childrenCount)
+      }
+    }
+
+    private def doSomethingWithNode(node: Node) = Console.println(node.id)
+
+    def dfsRecursive(): Unit = {
+      def dfsRecursive(node: Node): Unit = {
+        doSomethingWithNode(node)
+        node.children.foreach(dfsRecursive)
+      }
+
+      dfsRecursive(root)
+    }
+
+    def dfsRecursivePostOrder(): Unit = {
+      def dfsRecursivePostOrder(node: Node): Unit = {
+        node.children.foreach(dfsRecursivePostOrder)
+        doSomethingWithNode(node)
+      }
+
+      dfsRecursivePostOrder(root)
+    }
+
+    def dfsRecursiveInOrderBinary(): Unit = {
+      def processIfChildExists(children: ListBuffer[Node], index: Int) =
+        if (children.isDefinedAt(index))
+          dfsRecursiveInOrderBinary(children(index))
+
+      def dfsRecursiveInOrderBinary(node: Node): Unit = {
+        if (node.children.size > 2)
+          throw new Exception("Not a binary tree!")
+
+        processIfChildExists(node.children, 0)
+        doSomethingWithNode(node)
+        processIfChildExists(node.children, 1)
+      }
+
+      dfsRecursiveInOrderBinary(this.root)
+    }
+
+    def dfsStack(): Unit = {
+      val stack = new ArrayBuffer[Node]()
+      stack += root
+      while (stack.nonEmpty) {
+        doSomethingWithNode(stack(0))
+        stack ++= stack.remove(0).children
+      }
+    }
+
+    def bfsQueue(): Unit = {
+      val queue = new Queue[Node]()
+      queue.enqueue(root)
+      while (queue.nonEmpty) {
+        doSomethingWithNode(queue.head)
+        queue ++= queue.dequeue.children
+      }
+    }
+
+  }
+
+  def main(args: Array[String]): Unit = {
+    Console.println("Creating Tree")
+    var tree = new Tree(3, 3)
+
+    Console.println("Using recursive DFS :")
+    tree.dfsRecursive
+
+    Console.println("Using stack-based DFS :")
+    tree.dfsStack
+
+    Console.println("Using queue-based BFS :")
+    tree.bfsQueue
+
+    Console.println("Using post-order recursive DFS :")
+    tree.dfsRecursivePostOrder
+
+    // Uncommenting the following 2 lines will result in an exception thrown because at least one Node of the Tree
+    // has more than 2 children and therefor a DFSRecursiveInorderBinary doesn't work.
+    Console.println("Using in-order binary recursive DFS : (fail)")
+    tree.dfsRecursiveInOrderBinary
+
+    tree = new Tree(3, 2)
+    Console.println("Using in-order binary recursive DFS : (succeed)")
+    tree.dfsRecursiveInOrderBinary
+  }
+
+}

contents/tree_traversal/tree_traversal.md

@@ -36,6 +36,8 @@ As a note, a `node` struct is not necessary in javascript, so this is an example
 [import:5-8, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:24-27, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import:7-10, lang:"scala"](code/scala/tree.scala)
 {% 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:
@@ -74,6 +76,8 @@ Because of this, the most straightforward way to traverse the tree might be recu
 [import:10-15, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:290-314, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import:26-33, lang:"scala"](code/scala/tree.scala)
 {% 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:
@@ -120,6 +124,8 @@ Now, in this case the first element searched through is still the root of the tr
 [import:17-22, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:316-344, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import:35-42, lang:"scala"](code/scala/tree.scala)
 {% endmethod %}
 
 <p>
@@ -161,6 +167,8 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 [import:24-38, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:346-396, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import:44-59, lang:"scala"](code/scala/tree.scala)
 {% endmethod %}
 
 <p>
@@ -212,6 +220,8 @@ In code, it looks like this:
 [import:40-49, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:398-445, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import:62-70, lang:"scala"](code/scala/tree.scala)
 {% 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:
@@ -255,6 +265,8 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 [import:51-60, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:447-498, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import:71-78, lang:"scala"](code/scala/tree.scala)
 {% endmethod %}
 
 ## Example Code
@@ -300,9 +312,12 @@ The code snippets were taken from this [Scratch project](https://scratch.mit.edu
 [import, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="scala" %}
+[import, lang:"scala"](code/scala/tree.scala)
 {% endmethod %}
 
 
+
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
 </script>