add algo to convert heap into tree

src/main/kotlin/tree/HeapToTree.kt

@@ -0,0 +1,15 @@
+package tree
+
+object HeapToTree {
+
+ fun heapToTree( heap : Array<Int?> , index : Int = 0 ) : TreeNode? = when {
+ index >= heap.size || heap[index] == null -> null
+ else -> TreeNode( heap[index]!! ).apply {
+ left = heapToTree( heap , (index*2)+1 )
+ right = heapToTree( heap , (index*2)+2 )
+ }
+ }
+
+ fun heapToTree( vararg nodes : Int? ) : TreeNode? = heapToTree( arrayOf( *nodes ) )
+
+}

src/main/kotlin/tree/TreeNode.kt

@@ -0,0 +1,7 @@
+package tree
+
+data class TreeNode(
+ var `val` : Int ,
+ var left : TreeNode? = null ,
+ var right : TreeNode? = null
+)

src/main/kotlin/tree/TreeToHeap.kt

@@ -0,0 +1,40 @@
+package tree
+
+object TreeToHeap {
+
+ private fun TreeNode?.count( level : Int = 0 ) : Int = when {
+ this == null -> 0
+ else -> {
+ var current = 1
+ repeat( level ) { current *= 2 }
+ val left = left.count( level+1 )
+ val right = right.count( level+1 )
+ current + if ( left > right ) left else right
+ }
+ }
+
+ private fun TreeNode?.recursiveAdd( heap : Array<Int?> , index : Int = 0 ) {
+ this?.run {
+ heap[index] = `val`
+ left.recursiveAdd( heap , index*2+1 )
+ right.recursiveAdd( heap , index*2+2 )
+ }
+ }
+
+ private inline fun <reified T> Array<T?>.trimNullSuffix() : Array<T?> {
+ var i = size-1
+ while ( get( i ) == null ) i--
+ i++
+ val trimmedArray = Array<T?>(i){null}
+ for ( j in 0 until i ) trimmedArray[j] = get(j)
+ return trimmedArray
+ }
+
+ val TreeNode?.transformToHeap : Array<Int?>
+ get() {
+ val heap = Array<Int?>( count() ) { null }
+ recursiveAdd( heap )
+ return heap.trimNullSuffix()
+ }
+
+}

src/test/kotlin/tree/HeapToTreeTest.kt

@@ -0,0 +1,28 @@
+package tree
+
+import org.junit.Assert
+import org.junit.Test
+import tree.HeapToTree.heapToTree
+
+class HeapToTreeTest {
+
+ private fun check( custom : TreeNode? , generated : TreeNode? ) : Boolean {
+ if ( custom == null && generated == null ) return true
+ if ( custom == null || generated == null ) return false
+ val current = custom.`val` == generated.`val`
+ val left = check( custom.left , generated.left )
+ val right = check( custom.right , generated.right )
+ return current && left && right
+ }
+
+ @Test
+ fun testForGeneratedTree() {
+ val custom = TreeNode( 1 ).apply {
+ left = TreeNode( 2 )
+ right = TreeNode( 3 )
+ }
+ val generated = heapToTree( 1 , 2 , 3 )
+ Assert.assertTrue( check( custom , generated ) )
+ }
+
+}

src/test/kotlin/tree/TreeToHeapTest.kt

@@ -0,0 +1,20 @@
+package tree
+
+import org.junit.Assert
+import org.junit.Test
+import kotlin.random.Random
+import tree.HeapToTree.heapToTree
+import tree.TreeToHeap.transformToHeap
+
+class TreeToHeapTest {
+
+ @Test
+ fun treeToHeapTest() {
+ val array = Array<Int?>( Random.nextInt( 100 ) ) { null }
+ for ( i in array.indices) array[i] = Random.nextInt()
+ val transformed = heapToTree( array )
+ .transformToHeap
+ Assert.assertArrayEquals( array , transformed )
+ }
+
+}