Split Tree Traversal Challange (#141)

Author: igorwojda

README.md

@@ -103,7 +103,8 @@ multiple times and be persistent over time.
 - [Get duplicated arguments](src/test/kotlin/com/igorwojda/string/getduplicatedarguments)
 - [Find pair with target average](src/test/kotlin/com/igorwojda/list/pairaverage)
 - [Binary search tree](src/test/kotlin/com/igorwojda/tree/binarysearchtree)
-- [Tree traversal](src/test/kotlin/com/igorwojda/tree/multiway/traversal)
+- [Tree traversal (breath first)](src/test/kotlin/com/igorwojda/tree/multiway/traversal/breathfirst)
+- [Tree traversal (depth first)](src/test/kotlin/com/igorwojda/tree/multiway/traversal/depthfirst)
 - [Tree level width](src/test/kotlin/com/igorwojda/tree/multiway/levelwidth)
 - [Binary search tree (insert)](src/test/kotlin/com/igorwojda/tree/binarytree/insert)
 - [Binary search tree (validate)](src/test/kotlin/com/igorwojda/tree/binarytree/validate)

misc/ChallengeGroups.md

@@ -19,6 +19,7 @@ List of problems that can be solved using [recursion](https://en.wikipedia.org/w
 - [Capitalize first](../src/test/kotlin/com/igorwojda/list/capitalizefirst)
 - [Merge sort](../src/test/kotlin/com/igorwojda/list/sort/mergesort)
 - [Quick sort](../src/test/kotlin/com/igorwojda/list/sort/quicksort)
+- [Tree traversal (depth first)](../src/test/kotlin/com/igorwojda/tree/multiway/traversal/depthfirst)
 
 ### Recursion with helper function 
 
@@ -166,12 +167,12 @@ We use sliding window instead of nested loops which decreases complexity from `O
 
 - [Queue](../src/test/kotlin/com/igorwojda/queue/basic)
 - [Combine two queues](../src/test/kotlin/com/igorwojda/queue/combine)
-- [Tree traversal](../src/test/kotlin/com/igorwojda/tree/multiway/traversal)
+- [Tree traversal (breath first)](../src/test/kotlin/com/igorwojda/tree/multiway/traversal/breathfirst)
 
 ## Stack
 
 - [Stack](../src/test/kotlin/com/igorwojda/stack/basic)
-- [Tree traversal](../src/test/kotlin/com/igorwojda/tree/multiway/traversal)
+- [Tree traversal (depth first)](../src/test/kotlin/com/igorwojda/tree/multiway/traversal/depthfirst)
 
 ## Heap
 

src/test/kotlin/com/igorwojda/tree/multiway/traversal/Solution.kt

@@ -0,0 +1,114 @@
+package com.igorwojda.tree.multiway.traversal.breathfirst
+
+import org.amshove.kluent.shouldBeEqualTo
+import org.junit.jupiter.api.Test
+
+private fun traverseBreathFirst(tree: BinarySearchTree<Char>): List<Char> {
+    TODO("Add your solution here")
+}
+
+private class BinarySearchTree<E : Comparable<E>> {
+    var root: BinaryNode<E>? = null
+        private set
+
+    fun add(element: E) {
+        val newNode = BinaryNode(element)
+
+        if (root == null) {
+            root = newNode
+            return
+        }
+
+        var current: BinaryNode<E> = root ?: return
+
+        while (true) {
+            when {
+                current.data == element -> {
+                    return
+                }
+                element < current.data -> {
+                    if (current.left == null) {
+                        current.left = newNode
+                        return
+                    }
+
+                    current.left?.let { current = it }
+                }
+                element > current.data -> {
+                    if (current.right == null) {
+                        current.right = newNode
+                        return
+                    }
+
+                    current.right?.let { current = it }
+                }
+            }
+        }
+    }
+
+    fun contains(element: E): Boolean {
+        var current = root
+
+        while (true) {
+            if (current == null) {
+                break
+            } else if (current.data == element) {
+                return true
+            } else if (element < current.data) {
+                current = current.left
+            } else if (element > current.data) {
+                current = current.right
+            }
+        }
+
+        return false
+    }
+
+    fun isEmpty() = root == null
+}
+
+private data class BinaryNode<E : Comparable<E>>(
+    val data: E,
+    var left: BinaryNode<E>? = null,
+    var right: BinaryNode<E>? = null,
+)
+
+private class Test {
+    // ---------Tree------------
+    //
+    //           F
+    //         /   \
+    //        B     G
+    //       / \     \
+    //      A   D     I
+    //         / \   /
+    //        C   E H
+    //
+    // --------------------------
+    private fun getTree() = BinarySearchTree<Char>().apply {
+        add('F')
+        add('B')
+        add('A')
+        add('D')
+        add('C')
+        add('E')
+        add('G')
+        add('I')
+        add('H')
+    }
+
+    @Test
+    fun `traverse breath first`() {
+        traverseBreathFirst(getTree()) shouldBeEqualTo listOf(
+            'F',
+            'B',
+            'G',
+            'A',
+            'D',
+            'I',
+            'C',
+            'E',
+            'H',
+        )
+    }
+}

src/test/kotlin/com/igorwojda/tree/multiway/traversal/breathfirst/Challenge.kt

@@ -0,0 +1,34 @@
+# Tree traversal
+
+## Nice to solve before
+
+[Queue](../../../../queue/basic/README.md)
+
+## Instructions
+
+Traverse [tree](https://en.wikipedia.org/wiki/Tree_(data_structure)) using `Breath-First` traversal.
+
+Implement breath-first traversal - visit every node on a level before going to a lower level.
+
+![breadth_first_traversal.svg](misc/breadth_first_traversal.svg)
+
+## Examples
+
+```kotlin
+// ---------Tree------------
+//
+//           A
+//         /   \
+//        B     C
+//
+// --------------------------
+
+
+val tree = BinarySearchTree<Char>()
+tree.add('A')
+tree.add('B')
+tree.add('C')
+
+tree.traverseBreathFirst() // listOf('A', 'B', 'C')
+```
+