Added insert method for red black tree and template for test

.gitignore

@@ -180,4 +180,4 @@ gradle-app.setting
 # Java heap dump
 *.hprof
 
-# End of https://www.toptal.com/developers/gitignore/api/kotlin,java,gradle,intellij
+# End of https://www.toptal.com/developers/gitignore/api/kotlin,java,gradle,intellij

settings.gradle.kts

@@ -8,5 +8,5 @@
  */
 
 rootProject.name = "trees-3"
-include("app",)
+include("app")
 include("trees")

trees/build.gradle.kts

@@ -16,8 +16,7 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter-engine:5.9.1")
 }
 
-
 tasks.named<Test>("test") {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()
-}
+}

trees/src/main/kotlin/bst/AVLTree.kt

@@ -1,4 +1,3 @@
 package bst
 
-class AVLTree {
-}
+class AVLTree

trees/src/main/kotlin/bst/BalancingTree.kt

@@ -2,7 +2,7 @@ package bst
 
 import bst.nodes.TreeNode
 
-abstract class BalancingTree<K: Comparable<K>, V>: BinarySearchTree<K, V>() {
+abstract class BalancingTree<K : Comparable<K>, V> : BinarySearchTree<K, V>() {
     protected fun <SpecNode : TreeNode<K, V, SpecNode>> rotateLeft(node: SpecNode): SpecNode {
         val right = node.right
         node.right = right?.left
@@ -15,4 +15,4 @@ abstract class BalancingTree<K: Comparable<K>, V>: BinarySearchTree<K, V>() {
         left?.right = node
         return left!!
     }
-}
+}

trees/src/main/kotlin/bst/BinarySearchTree.kt

@@ -2,7 +2,7 @@ package bst
 
 import bst.nodes.BSTNode
 
-open class BinarySearchTree<K: Comparable<K>, V>: Tree<K, V> {
+open class BinarySearchTree<K : Comparable<K>, V> : Tree<K, V> {
     var rootNode: BSTNode<K, V>? = null
     override fun insert(key: K, value: V) {
         val newNode = BSTNode(key, value)
@@ -38,18 +38,17 @@ open class BinarySearchTree<K: Comparable<K>, V>: Tree<K, V> {
         }
     }
 
-    override fun remove(key: K, value: V) {
-        //remove node by key
+    override fun remove(key: K) {
+        // remove node by key
         TODO("Not yet implemented")
     }
-
     override fun find(key: K): Boolean {
         return this.search(this.rootNode, key) != null
-//        return this.search(this.rootNode, key)
-        //this method gives element by key
+        // return this.search(this.rootNode, key)
+        // this method gives element by key
     }
+
     private fun search(currentNode: BSTNode<K, V>?,  key: K): BSTNode<K, V>? {
-
         if (currentNode==null){
             return null
         }
@@ -69,17 +68,16 @@ open class BinarySearchTree<K: Comparable<K>, V>: Tree<K, V> {
 //        return currentNode
     }
 
-    fun symmetricalTreeTraversal(){
-
+    fun symmetricalTreeTraversal() {
+        TODO()
     }
 
     override fun clear() {
         TODO("Not yet implemented")
     }
 }
 
-
-fun main(){
+fun main() {
     val test_tree = BinarySearchTree<Int, String>()
     test_tree.insert(234, "afaraf")
     test_tree.insert(235, "afaraf")

trees/src/main/kotlin/bst/Main.kt

@@ -6,4 +6,4 @@ fun main(args: Array<String>) {
     // Try adding program arguments via Run/Debug configuration.
     // Learn more about running applications: https://www.jetbrains.com/help/idea/running-applications.html.
     println("Program arguments: ${args.joinToString()}")
-}
+}

trees/src/main/kotlin/bst/RedBlackTree.kt

@@ -2,47 +2,94 @@ package bst
 
 import bst.nodes.RBTNode
 
-class RedBlackTree<K: Comparable<K>, V>: Tree<K, V> {
+class RedBlackTree<K : Comparable<K>, V> : BalancingTree<K, V>() {
+    private var root: RBTNode<K, V>? = null
 
-    override fun find(key: K): Boolean{
-        TODO("Not yet implemented")
+    private fun isRed(node: RBTNode<K, V>?): Boolean {
+        return node?.red == true
     }
 
-    override fun clear() {
-        TODO("Not yet implemented")
-    }
     override fun insert(key: K, value: V) {
-        TODO()
+        insertNode(key, value)
     }
 
-    private fun insertNode(node: RBTNode<K, V>): RBTNode<K, V> {
-        TODO()
-    }
+    private fun insertNode(key: K, value: V): RBTNode<K, V> {
+        if (root == null) {
+            root = RBTNode(key, value, true)
+            return root!!
+        }
 
-    override fun remove(key: K, value: V) {
+        var node = root
+        var parent: RBTNode<K, V>? = null
 
-    }
-    private fun removeNode(node: RBTNode<K, V>): RBTNode<K, V> {
-        TODO()
-    }
+        while (node != null) {
+            parent = node
 
-    private fun moveRedLeft(node: RBTNode<K, V>): RBTNode<K, V> {
-        TODO()
-    }
+            when {
+                key < node.key -> node = node.left
+                key > node.key -> node = node.right
+                else -> {
+                    node.value = value
+                    return node
+                }
+            }
+        }
 
-    private fun moveRedRight(node: RBTNode<K, V>): RBTNode<K, V> {
-        TODO()
-    }
+        val newNode = RBTNode(key, value, false)
+        if (key < parent!!.key) {
+            parent.left = newNode
+        } else {
+            parent.right = newNode
+        }
 
-    private fun rotateRight(node: RBTNode<K, V>) {
-        TODO()
+        var current = newNode
+        while (isRed(current) && isRed(current.left)) {
+            var sibling = current.right
+            if (isRed(sibling)) {
+                current.red = true
+                sibling!!.red = false
+                current = rotateLeft(current)
+
+                current.red = current.left!!.red
+                current.left!!.red = true
+
+                sibling = current.right
+            }
+            if (!isRed(sibling?.left) && !isRed(sibling?.right)) {
+                sibling!!.red = true
+                current = parent
+            } else {
+                if (!isRed(sibling?.right)) {
+                    sibling!!.left?.red = false
+                    sibling.red = true
+                    current = rotateRight(sibling)
+
+                    current.red = current.right!!.red
+                    current.right!!.red = true
+
+                    sibling = current.right
+                }
+                sibling!!.red = current.red
+                current.red = true
+                sibling.right?.red = true
+                current = rotateLeft(current)
+
+                current.red = current.left!!.red
+                current.left!!.red = true
+
+                break
+            }
+        }
+
+        root!!.red = true
+        return current
     }
 
-    private fun rotateLeft(node: RBTNode<K, V>) {
+    override fun remove(key: K) {
         TODO()
     }
 
-    private fun balance(node: RBTNode<K, V>) {
+    private fun removeNode(node: RBTNode<K, V>): RBTNode<K, V> {
         TODO()
     }
-}
+}

trees/src/main/kotlin/bst/Tree.kt

@@ -1,9 +1,8 @@
 package bst
 
-interface Tree<K: Comparable<K>, V>  {
+interface Tree<K : Comparable<K>, V> {
     fun insert(key: K, value: V)
     fun remove(key: K, value: V)
     fun find(key: K): Boolean
     fun clear()
 }
-

trees/src/main/kotlin/bst/nodes/AVLNode.kt

@@ -1,4 +1,3 @@
 package bst.nodes
 
-class AVLNode {
-}
+class AVLNode

trees/src/main/kotlin/bst/nodes/BSTNode.kt

@@ -1,9 +1,9 @@
 package bst.nodes
 
-class BSTNode<K: Comparable<K>, V> (
+class BSTNode<K : Comparable<K>, V> (
     override val key: K,
-    override var value: V,
-): TreeNode<K, V, BSTNode<K, V>> {
+    override var value: V
+) : TreeNode<K, V, BSTNode<K, V>> {
     override var left: BSTNode<K, V>? = null
     override var right: BSTNode<K, V>? = null
-}
+}

trees/src/main/kotlin/bst/nodes/RBTNode.kt

@@ -1,28 +1,11 @@
 package bst.nodes
 
-enum class Color{
-    BLACK,
-    RED
-}
-
 // хз насчет data class, мб че-то заходим в самой ноде делать
-class RBTNode<K: Comparable<K>, V> (
+class RBTNode<K : Comparable<K>, V> (
     override val key: K,
     override var value: V,
-): TreeNode<K, V, RBTNode<K, V>> {
+    var red: Boolean = true
+) : TreeNode<K, V, RBTNode<K, V>> {
     override var left: RBTNode<K, V>? = null
     override var right: RBTNode<K, V>? = null
-    var color = Color.BLACK
-
-    internal fun isBlack() {
-        TODO()
-    }
-    internal fun isRed() {
-        TODO()
-    }
-    internal fun flipColors() {
-        TODO()
-    }
-
-
-}
+}

trees/src/main/kotlin/bst/nodes/TreeNode.kt

@@ -1,7 +1,7 @@
 package bst.nodes
 
 // а надо ли нам тогда value? хер знает
-interface TreeNode<K: Comparable<K>, V, SpecNode : TreeNode<K, V, SpecNode>> {
+interface TreeNode<K : Comparable<K>, V, SpecNode : TreeNode<K, V, SpecNode>> {
     val key: K
     var value: V
     var left: SpecNode?

trees/src/test/kotlin/bst/ValidRBTTest.kt

@@ -0,0 +1,30 @@
+package bst
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class ValidRBTTest {
+
+    @Test
+    fun testInsert() {
+        val tree = RedBlackTree<Int, String>()
+        tree.insert(1, "One")
+        tree.insert(2, "Two")
+        tree.insert(3, "Three")
+        assertEquals("One", tree.find(1))
+        assertEquals("Two", tree.find(2))
+        assertEquals("Three", tree.find(3))
+    }
+
+    @Test
+    fun testDelete() {
+        val tree = RedBlackTree<Int, String>()
+        tree.insert(1, "One")
+        tree.insert(2, "Two")
+        tree.insert(3, "Three")
+        tree.remove(2)
+        assertEquals(null, tree.find(2))
+        assertEquals("One", tree.find(1))
+        assertEquals("Three", tree.find(3))
+    }
+}