Add tree traversal

Author: Romanow

src/main/kotlin/ru/romanow/algorithms/BinarySearchTree.kt

@@ -0,0 +1,14 @@
+package ru.romanow.algorithms
+
+import ru.romanow.models.TreeNode
+
+class BinarySearchTree {
+    fun find(root: TreeNode?, target: Int): TreeNode? {
+        return when {
+            root == null -> null
+            target == root.value -> root
+            target < root.value -> find(root.left, target)
+            else -> find(root.right, target)
+        }
+    }
+}

src/main/kotlin/ru/romanow/algorithms/TreeTraversal.kt

@@ -0,0 +1,69 @@
+package ru.romanow.algorithms
+
+import ru.romanow.models.TreeNode
+import ru.romanow.models.buildTreeFromList
+import java.util.*
+
+fun main() {
+    val root = buildTreeFromList(listOf(10, 5, 15, 3, 7, 12, 20))
+    printTree(root)
+    preOrder(root)
+    println()
+    inOrder(root)
+    println()
+    postOrder(root)
+    println()
+    bfs(root)
+}
+
+private fun printTree(node: TreeNode?, level: Int = 0) {
+    if (node == null) return
+    print("  ".repeat(level))
+    println("├─ ${node.value}")
+    printTree(node.left, level + 1)
+    printTree(node.right, level + 1)
+}
+
+private fun preOrder(node: TreeNode?) {
+    if (node == null) {
+        return
+    }
+    print("${node.value} ")
+    preOrder(node.left)
+    preOrder(node.right)
+}
+
+private fun inOrder(node: TreeNode?) {
+    if (node == null) {
+        return
+    }
+    inOrder(node.left)
+    print("${node.value} ")
+    inOrder(node.right)
+}
+
+private fun postOrder(node: TreeNode?) {
+    if (node == null) {
+        return
+    }
+    postOrder(node.left)
+    postOrder(node.right)
+    print("${node.value} ")
+}
+
+private fun bfs(root: TreeNode?) {
+    if (root == null) {
+        return
+    }
+
+    val queue = LinkedList<TreeNode>()
+    queue.add(root)
+
+    while (queue.isNotEmpty()) {
+        val node = queue.poll()
+        print("${node.value} ")
+
+        node.left?.let { queue.add(it) }
+        node.right?.let { queue.add(it) }
+    }
+}

src/main/kotlin/ru/romanow/models/TreeNode.kt

@@ -1,25 +1,10 @@
 package ru.romanow.models
 
-import java.util.LinkedList
+import java.util.*
 
-class TreeNode {
-    var value: Int? = null
+data class TreeNode(var value: Int) {
     var left: TreeNode? = null
     var right: TreeNode? = null
-
-    constructor(value: Int?) {
-        this.value = value
-    }
-
-    constructor(value: Int?, left: TreeNode?, right: TreeNode?) {
-        this.value = value
-        this.left = left
-        this.right = right
-    }
-
-    override fun toString(): String {
-        return "TreeNode(value=$value, left=${left?.value}, right=${right?.value})"
-    }
 }
 
 fun buildListFromTree(root: TreeNode?): List<Int?> {
@@ -41,10 +26,10 @@ fun buildListFromTree(root: TreeNode?): List<Int?> {
     return list
 }
 
-fun buildTreeFromList(values: List<Int?>, index: Int): TreeNode? {
+fun buildTreeFromList(values: List<Int?>, index: Int = 0): TreeNode? {
     var node: TreeNode? = null
     if (index < values.size && values[index] != null) {
-        node = TreeNode(value = values[index])
+        node = TreeNode(value = values[index]!!)
         node.left = buildTreeFromList(values, 2 * index + 1)
         node.right = buildTreeFromList(values, 2 * index + 2)
     }

src/test/kotlin/ru/romanow/algorithms/BinarySearchTreeTest.kt

@@ -0,0 +1,29 @@
+package ru.romanow.algorithms
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.provider.ArgumentsSource
+import ru.romanow.models.buildTreeFromList
+import java.util.stream.Stream
+
+class BinarySearchTreeTest {
+
+    @ArgumentsSource(ValueProvider::class)
+    @ParameterizedTest(name = "#{index} – Search {1} in tree {0}")
+    fun flatten(items: List<Int?>, target: Int, result: Int?) {
+        val root = buildTreeFromList(items)
+        val obj = BinarySearchTree()
+        assertThat(obj.find(root, target)?.value).isEqualTo(result)
+    }
+
+    internal class ValueProvider : ArgumentsProvider {
+        override fun provideArguments(context: ExtensionContext): Stream<Arguments> =
+            Stream.of(
+                Arguments.of(listOf(10, 5, 15, 3, 7, 12, 20), 20, 20),
+                Arguments.of(listOf(10, 5, 15, 3, 7, 12, 20), 0, null)
+            )
+    }
+}

src/test/kotlin/ru/romanow/medium/DeleteNodeInABalancedSearchTreeTest.kt

@@ -16,7 +16,7 @@ class DeleteNodeInABalancedSearchTreeTest {
     @ParameterizedTest(name = "#{index} – Tree {0} after removing key {1} is {2}")
     fun deleteNode(values: List<Int?>, key: Int, expectedResult: List<Int?>) {
         val obj = DeleteNodeInABalancedSearchTree()
-        val root = buildTreeFromList(values, 0)
+        val root = buildTreeFromList(values)
         val result = buildListFromTree(obj.deleteNode(root, key))
         assertThat(result).isEqualTo(expectedResult)
     }

src/test/kotlin/ru/romanow/medium/FlattenBinaryTreeToLinkedListTest.kt

@@ -15,7 +15,7 @@ class FlattenBinaryTreeToLinkedListTest {
     @ArgumentsSource(ValueProvider::class)
     @ParameterizedTest(name = "#{index} – Binary tree {0} flatten into {1}")
     fun flatten(items: List<Int?>, result: List<Int>) {
-        val root = buildTreeFromList(items, 0)
+        val root = buildTreeFromList(items)
 
         val obj = FlattenBinaryTreeToLinkedList()
         obj.flatten(root)