Almost endded Testing adding and removing and corrected them

IslamZZZZ · IslamZZZZ · commit 3a4d514e6c96 · 2024-10-28T21:38:42.000+03:00
diff --git a/src/main/kotlin/treeLib/bintrees/interfaces/Treap.kt b/src/main/kotlin/treeLib/bintrees/interfaces/Treap.kt
@@ -19,16 +19,14 @@ class Treap<K : Comparable<K>, V: Comparable<V> > : BinTree<K, V, TreapNode<K, V
         if(node.left != null) node.left?.let{ collectNodes(it) }
     }
 
-    fun buildSubTree(): TreapNode<K, V> {
-        var baum = Treap<K, V>()
+    fun buildSubTree(): TreapNode<K, V>? {
+        val baum = Treap<K, V>()
         for(node in subTree) baum.add(node.key, node.value)
-        baum.root?.let { baum.collectNodes(it) }
+        /*baum.root?.let { baum.collectNodes(it) }
         subTree = baum.subTree  //После такого оно сохранит свойство автоматической сортировки иль як?
-        return subTree.first()
-        /*
-        subTree.clean()
-        baum.root?.let { return it }
-         */
+        return subTree.first()*/
+        subTree.clear()
+        return baum.root()
         //Может быть можно не собирать массив, а просто взять корень и уже с ним работать?
     }
 
@@ -48,10 +46,10 @@ class Treap<K : Comparable<K>, V: Comparable<V> > : BinTree<K, V, TreapNode<K, V
 
     override fun remove(key: K): V? {
         if(root == null) return null
-        /*if(root?.key == key && amountOfNodes == 1) {
+        if(root?.key == key && amountOfNodes == 1) {
             amountOfNodes -= 1
             root = null
-        }*/
+        }
 
         val parent = this.findParent(key)
         var count = 0
@@ -62,7 +60,7 @@ class Treap<K : Comparable<K>, V: Comparable<V> > : BinTree<K, V, TreapNode<K, V
 
         if(count == 0) {
             if(parent?.right == curNode) parent?.right = null
-            else parent?.left == null
+            else parent?.left = null
         }
         if(count == 1) {
             if(parent?.right == curNode) parent?.right = curNode?.right ?: curNode?.left
@@ -72,9 +70,8 @@ class Treap<K : Comparable<K>, V: Comparable<V> > : BinTree<K, V, TreapNode<K, V
             curNode?.right?.let { collectNodes(it) }
             curNode?.left?.let { collectNodes(it) }
             val result = buildSubTree()
-            if(parent == root) root = result
-            else if(parent?.right == curNode) parent?.right = result
-            else parent?.left == result
+            if(parent?.right == curNode) parent?.right = result
+            else parent?.left = result
         }
         return null
     }
@@ -98,7 +95,7 @@ class Treap<K : Comparable<K>, V: Comparable<V> > : BinTree<K, V, TreapNode<K, V
                     it.right = buildSubTree()
                 }
             }
-            else if(it.key < key)( //Не забудь подумать о случае, когда добавленный ключ вже существует
+            else if(it.key > key)( //Не забудь подумать о случае, когда добавленный ключ вже существует
                 if(it.left == null) it.left = newNode
                 else{
                     newNode.left = it.left
@@ -112,15 +109,16 @@ class Treap<K : Comparable<K>, V: Comparable<V> > : BinTree<K, V, TreapNode<K, V
                 root = buildSubTree()
             }
 
-                amountOfNodes += 1
-                return newNode
+            amountOfNodes += 1
+            return newNode
         }
 
         return root
     }
 
 
     fun x(curNode: TreapNode<K, V>, parent: TreapNode<K, V>, node: TreapNode<K, V>): TreapNode<K, V>{
+        //Добавь ? к возвращаему значению чтоб отработать случаи одинаковости ключа и/иль приоритета
         if(curNode.value < node.value) {
             if(curNode == parent) return node
             return parent
diff --git a/src/test/kotlin/TreapTest.kt b/src/test/kotlin/TreapTest.kt
@@ -1,3 +1,4 @@
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 import treeLib.bintrees.BSTree
@@ -8,6 +9,78 @@ import kotlin.test.assertEquals
 class TreapTest {
     var baum = Treap<Int, Int>()
 
+    @Nested
+    inner class TestindRemoveMethod {
+
+        @BeforeEach
+        fun setUp() {
+            baum.add(20,100)
+            baum.add(50,90)
+            baum.add(35,80)
+            baum.add(40,70)
+            baum.add(30,60)
+            baum.add(70,50)
+            baum.add(60,40)
+            baum.add(80,30)
+        }
+
+        @Test
+        fun removeNodeWithoutChildren() {
+            val rt = baum.root()?.right?.left
+
+            baum.remove(40)
+            assertEquals(null, rt?.right)
+
+            baum.remove(30)
+            assertEquals(null, rt?.left)
+
+            baum.remove(35)
+            assertEquals(null, baum.root()?.right?.left)
+        }
+
+        @Test
+        fun removeNodeWithOnlyOneChild() {
+            baum.remove(60)
+            baum.remove(80)
+            baum.remove(70)
+            assertEquals(null, baum.root()?.right?.right)
+
+            baum.remove(50)
+            assertEquals(TreapNode(35, 80), baum.root()?.right)
+        }
+
+        @Test
+        fun removeNodeWithTwoChildrenFirstCase() {
+            val rt = baum.root()?.right
+            baum.remove(35)
+
+            assertEquals(TreapNode(40, 70), rt?.left)
+            assertEquals(TreapNode(30,60), rt?.left?.left)
+        }
+
+        @Test
+        fun removeNodeWithTwoChildrenSecondCase() {
+            val rt = baum.root()?.right
+            baum.remove(70)
+
+            assertEquals(TreapNode(60, 40), rt?.right)
+            assertEquals(TreapNode(80, 30), rt?.right?.right)
+        }
+
+        @Test
+        fun removeNodeWithTwoChildrenThirdCase() {
+            val rt = baum.root()
+            baum.remove(50)
+
+            assertEquals(TreapNode(35,80), rt?.right)
+            assertEquals(TreapNode(30,60), rt?.right?.left)
+            assertEquals(TreapNode(40,70), rt?.right?.right)
+            assertEquals(TreapNode(70,50), rt?.right?.right?.right)
+            assertEquals(TreapNode(60,40), rt?.right?.right?.right?.left)
+            assertEquals(TreapNode(80,30), rt?.right?.right?.right?.right)
+        }
+    }
+
 
     @Nested
     inner class TestingAddingMethod {
@@ -20,7 +93,7 @@ class TreapTest {
 
 
         @Test
-        fun addingLikeInBST() {
+        fun addingLikeInBSTree() {
             baum.add(4, 60)
             baum.add(7, 50)
             baum.add(2, 40)
@@ -41,12 +114,72 @@ class TreapTest {
         }
 
         @Test
-        fun changinRoot() {
+        fun changingRootToLeft() {
             baum.add(2, 10)
             baum.add(4,20)
 
             assertEquals(TreapNode(4,20), baum.root())
             assertEquals(TreapNode(2,10), baum.root()?.left)
         }
+
+        @Test
+        fun changingRootToRight() {
+            baum.add(4, 10)
+            baum.add(2,20)
+
+            assertEquals(TreapNode(2,20), baum.root())
+            assertEquals(TreapNode(4,10), baum.root()?.right)
+        }
+
+        @Test
+        fun addingLikeInBSTreeAndChangingByAddingRootLeftAndRightChildren() {
+            baum.add(4, 60)
+            baum.add(7, 50)
+            baum.add(2, 40)
+            baum.add(10, 30)
+            baum.add(-1, 20)
+            baum.add(3, 10)
+            baum.add(1, 0)
+            baum.add(11, 55)
+            baum.add(0, 45)
+
+            val rt = baum.root()
+
+            assertEquals(TreapNode(4, 60), baum.root())
+            assertEquals(TreapNode(11,55), rt?.right)
+            assertEquals(TreapNode(0,45), rt?.left)
+            assertEquals(TreapNode(7,50), rt?.right?.left)
+            assertEquals(TreapNode(10,30), rt?.right?.left?.right)
+            assertEquals(TreapNode(2,40), rt?.left?.right)
+            assertEquals(TreapNode(3,10), rt?.left?.right?.right)
+            assertEquals(TreapNode(1,0), rt?.left?.right?.left)
+            assertEquals(TreapNode(-1,20), rt?.left?.left)
+        }
+
+        @Test
+        fun changingSubTreesFarFromRoot() {
+            baum.add(20,100)
+            baum.add(50,90)
+            baum.add(35,80)
+            baum.add(40,70)
+            baum.add(30,60)
+            baum.add(70,50)
+            baum.add(60,40)
+            baum.add(80,30)
+            baum.add(32, 85)
+            baum.add(75, 65)
+
+            val rt = baum.root()
+
+            assertEquals(TreapNode(20,100), rt)
+            assertEquals(TreapNode(32,85), rt?.right?.left)
+            assertEquals(TreapNode(75,65), rt?.right?.right)
+            assertEquals(TreapNode(30, 60), rt?.right?.left?.left)
+            assertEquals(TreapNode(35,80), rt?.right?.left?.right)
+            assertEquals(TreapNode(40,70), rt?.right?.left?.right?.right)
+            assertEquals(TreapNode(80,30), rt?.right?.right?.right)
+            assertEquals(TreapNode(70,50), rt?.right?.right?.left)
+            assertEquals(TreapNode(60,40), rt?.right?.right?.left?.left)
+        }
     }
 }
